python - exercício 1

entrada.py

UNIDADE    = 1
CAIXA_PCTE = 2
DUZIA      = 3 

def formata_codigo(codigo):
	return codigo.zfill(10)

def formata_nome(nome):
	return nome.upper()

def existe_categoria(cod_categoria):
	return int(cod_categoria) in range(1,6)

def eh_valor_unitario_valido(valor):
    valor_valido = True
    for char in valor:
        if not char.isdigit() and char != "." and char != ",":
            valor_valido = False
            break
    return valor_valido

def formata_valor(valor):
	return float( valor.replace(",", ".") )

def existe_unidade(cod_categoria):
	return int(cod_categoria) in range(1,4)

def obter_desc_categoria(cod):
	if   cod == 1:
		return "Eletronicos"
	elif cod == 2:
		return "Moveis"
	elif cod == 3:
		return "Alimentos"
	elif cod == 4:
		return "Roupas"
	elif cod == 5:
		return "Outros"
	else:
		return None

def obter_desc_unidade(cod):
	if cod == UNIDADE:
		return "Unidade"
	elif cod == CAIXA_PCTE:
		return "Caixa/Pacote"
	elif cod == DUZIA:
		return "Duzia"
	else:
		return None
		
def totaliza_itens(quantidade, itens):
	return quantidade * itens
	
def totaliza_valor(valor_unitario, quantidade, itens):
	return valor_unitario * totaliza_itens(quantidade, itens)  
	
def obter_peso_unitario(peso_total, quantidade, itens):
	return peso_total / totaliza_itens(quantidade, itens) 

entrada_test.py

# -*- coding: utf-8 -*-

from entrada import *
import unittest

class Test(unittest.TestCase):
    
    # Garantir que o código do produto seja armazenado com 10 caracteres 0000000000
    # Ex: Entrada '123' transforme em '0000000123'
    def testFormataCodigo(self):
    	codigo = "389"    	
    	codigo = formata_codigo(codigo)
    	assert(codigo.__len__() == 10)

    # O nome do produto precisa estar em maiusculas
    # Ex: Entrada 'Nome do Produto' transforme em 'NOME DO PRODUTO'
    def testNomeMaiusculo(self):
        nome = "Oswaldo"
        assert( nome != "OSWALDO" )
        nome = formata_nome(nome)
        assert( nome == "OSWALDO" )

    # Deixaremos o tratamento de erros de forma correta para depois, por enquanto
    # caso o usuário digite uma categoria que não existe iremos exibir uma mensagem
    # e solicitar que entre novamente com o numero da categoria (uma tentativa)
    def testVerificaExistenciaCategoria(self):
    	categoria = "4"
    	assert(existe_categoria(categoria))
    	categoria = "1"
    	assert(existe_categoria(categoria))
    	categoria = "0"
    	assert(not existe_categoria(categoria))
    	categoria = "5"
    	assert(existe_categoria(categoria))
    	categoria = "6"
    	assert(not existe_categoria(categoria))

    # preciso garantir que entre apenas numeros, pontos ou virgulas
    def testVerificaValorUnitario(self):
    	valor = "2.a3"   	
    	assert( not eh_valor_unitario_valido(valor) )
    	valor = "2.056"
    	assert( eh_valor_unitario_valido(valor) )
    

    # Garantir que o valor seja convertido para float()
    # caso o usuario entre com , precisamos substituir por .
    def testFormataValorUnitario(self):
        valor = "2,56"
        valor = formata_valor(valor)
        assert( type(valor) == float )
        valor = "2.56"
        valor = formata_valor(valor)
        assert( type(valor) == float )        

	# Caso o usuario digite um numero de unidade que não existe, faça o mesmo que 
	# fez na categoria
    def testVerificaExistenciaUnidae(self):
    	unidade = "2"
    	assert(existe_unidade(unidade))
    	unidade = "1"
    	assert(existe_unidade(unidade))
    	unidade = "0"
    	assert(not existe_unidade(unidade))
    	unidade = "3"
    	assert(existe_unidade(unidade))
    	unidade = "4"
    	assert(not existe_unidade(unidade))

    def testUnidadeMedidaCtes(self):
        unidade_medida = 1
        assert unidade_medida == UNIDADE

        unidade_medida = 2
        assert unidade_medida == CAIXA_PCTE
        	
        unidade_medida = 3
        assert unidade_medida == DUZIA        
     
    def testObterDescCategoria(self):
    	for cod in range(1,6):
    		assert obter_desc_categoria(cod) != None

		cat_invalida = 10

        assert obter_desc_unidade(cat_invalida) == None

    def testObterDescUnidade(self):
        for cod in range(1,4):
    		assert obter_desc_unidade(cod) != None    	
        
        unid_invalida = 4

        assert obter_desc_unidade(unid_invalida) == None

    def testTotalizarItens(self):
    	assert totaliza_itens(10, 2) == 20

    def testTotalizarValor(self):
    	assert totaliza_valor(2, 10, 2) == 40

    def testObterPesoUnitario(self):
        peso_total = 20.0
        itens = 5
    	qtd = 2
    	assert obter_peso_unitario(peso_total, qtd, itens) == 2.0

if __name__ == "__main__":
    unittest.main()

jan12_exercicio_1.py

# -*- coding: utf-8 -*-

from entrada import *

################################################################################
#
# CONSTANTES
#
################################################################################

TEXTO_CATEGORIA = """###################
#___CATEGORIAS____#
# 1 = Eletronicos #
# 2 = Moveis      #
# 3 = Alimentos   #
# 4 = Roupas      #
# 5 = Outros      #
###################"""

TEXTO_UNIDADE = """###################
#_____UNIDADE_____#
# 1 = Unidade     #
# 2 = Caixa/Pcte  #
# 3 = Duzia       #
###################"""

################################################################################
#
# ENTRADA DE DADOS
#
################################################################################

print "SISTEMA DE ENTRADA DE PRODUTOS"
print "Por favor insira os dados do produto"
codigo = raw_input("Codigo:\n")
codigo = formata_codigo(codigo)

nome = raw_input("nome\n")
nome = formata_nome(nome)

print TEXTO_CATEGORIA
categoria = raw_input("Categoria:\n")
if not existe_categoria(categoria):
	print "ATENÇÃO: Por favor, verifique a categoria informada"
	print TEXTO_CATEGORIA
	categoria = raw_input("Categoria:\n")

categoria = int(categoria)

valor_unitario = raw_input("Valor Unitario:\n")
if not eh_valor_unitario_valido(valor_unitario):
	print "ATENÇÃO: Por favor, verifique o valor unitario informado"
	valor_unitario = raw_input("Valor Unitario:\n")

valor_unitario = formata_valor(valor_unitario)    


print TEXTO_UNIDADE
unidade_medida = raw_input("Unidade:\n")
if not existe_unidade(unidade_medida):
	print "ATENÇÃO: Por favor, verifique a unidade informada"
	print TEXTO_UNIDADE
	unidade_medida = raw_input("Unidade:\n")

unidade_medida = int(unidade_medida)

if unidade_medida == CAIXA_PCTE:
    itens = raw_input("Quantidade de itens por caixa/Pcte:\n")
    quantidade = raw_input("Quantidade de Caixas/PCtes\n")
elif unidade_medida == DUZIA:
    itens = 12
    quantidade = raw_input("Quantidade de Duzias\n")
else:
    itens = 1
    quantidade = raw_input("Quantidade:\n")

itens = int(itens)
quantidade = int(quantidade)

peso = raw_input("Peso total em quilos:\n")

peso = formata_valor(peso)

LINHA = "#" * 37
BORDA = "#" + " " * 35 + "#"
CONTEUDO = "#" + "%s" + "#"

print LINHA
print CONTEUDO % "RESUMO DA TRANSAÇÃO".center(37)
print BORDA
texto = "Código do produto: %s" % codigo
print CONTEUDO % texto.center(36)
texto = "Categoria: %s" % obter_desc_categoria(categoria)
print CONTEUDO % texto.center(35)
texto = "Valor unitário: %.2f" % float(valor_unitario)
print CONTEUDO % texto.center(36)
texto = "Unidade: %s" % obter_desc_unidade(int(unidade_medida))
print CONTEUDO % texto.center(35)
if unidade_medida == DUZIA or unidade_medida == CAIXA_PCTE:
    texto = "Itens por %s: %s" % (obter_desc_unidade(int(unidade_medida)), itens)
    print CONTEUDO % texto.center(35)
texto = "Quantidade: %s" % quantidade
print CONTEUDO % texto.center(35)
texto = "Peso: %.3f" % float(peso)
print CONTEUDO % texto.center(35)
print BORDA
print CONTEUDO % "TOTAIS".center(35)
texto = "Total de itens: %s" % totaliza_itens(quantidade, itens) 
print CONTEUDO % texto.center(35)
texto = "Valor total: %.2f" % totaliza_valor(valor_unitario, quantidade, itens)
print CONTEUDO % texto.center(35)
texto = "Peso total: %.3f" % float(peso)
print CONTEUDO % texto.center(35)
texto = "Peso por item: %.3f" % obter_peso_unitario(peso, quantidade, itens)
print CONTEUDO % texto.center(35)
print BORDA
print LINHA

Show! Procurando por outras coisas acabei caindo aqui e já aprendi como fazer teste de unidade com python! abraços