├── arquivo.py ├── conexao.py ├── microcomputador.py ├── teste_conexao.py ├── servidor.py ├── teste_microcomputador.py ├── impressora.py ├── teste_servidor.py ├── usuario.py ├── teste_arquivo.py ├── teste_usuario.py ├── readme.md └── teste_impressora.py /arquivo.py: -------------------------------------------------------------------------------- 1 | class Arquivo(object): 2 | 3 | def __init__(self, nome, proprietario, impressora_destino): 4 | self.nome = nome 5 | self.proprietario = proprietario 6 | self.impressora_destino = impressora_destino 7 | 8 | -------------------------------------------------------------------------------- /conexao.py: -------------------------------------------------------------------------------- 1 | class Conexao(object): 2 | 3 | conexoes = [] 4 | 5 | def __init__(self, nome, data, hora_inicio): 6 | self.nome = nome 7 | self.data = data 8 | self.hora_inicio = hora_inicio 9 | self.arquivos_enviados = {} 10 | 11 | @staticmethod 12 | def adicionar_conexao(conexao): 13 | Conexao.conexoes.append(conexao) 14 | -------------------------------------------------------------------------------- /microcomputador.py: -------------------------------------------------------------------------------- 1 | class Microcomputador(object): 2 | 3 | def __init__(self, codigo_implementacao, descricao, capacidade_do_hd, quantidade_de_ram, estacao): 4 | self.codigo_implementacao = codigo_implementacao 5 | self.descricao = descricao 6 | self.capacidade_do_hd = capacidade_do_hd 7 | self.quantidade_de_ram = quantidade_de_ram 8 | self.estacao = estacao 9 | -------------------------------------------------------------------------------- /teste_conexao.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from usuario import Usuario 4 | from conexao import Conexao 5 | 6 | class TestConexao(unittest.TestCase): 7 | 8 | def teste_deve_criar_uma_conexao(self): 9 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 10 | usuario.conectar() 11 | usuario.esta_conectado |should| equal_to(True) 12 | 13 | if __name__ == "__main__": 14 | unittest.main() 15 | -------------------------------------------------------------------------------- /servidor.py: -------------------------------------------------------------------------------- 1 | from microcomputador import Microcomputador 2 | 3 | class Servidor(Microcomputador): 4 | 5 | servidores = [] 6 | 7 | def __init__(self, codigo_implementacao, descricao, capacidade_do_hd, quantidade_de_ram, estacao, quantidade_maxima_de_buffer): 8 | Microcomputador.__init__(self, codigo_implementacao, descricao, capacidade_do_hd, quantidade_de_ram, estacao) 9 | self.quantidade_maxima_de_buffer = quantidade_maxima_de_buffer 10 | self.impressoras_conectadas = 0 11 | Servidor.adicionar_servidor(self) 12 | 13 | @staticmethod 14 | def adicionar_servidor(servidor): 15 | Servidor.servidores.append(servidor) 16 | -------------------------------------------------------------------------------- /teste_microcomputador.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from microcomputador import Microcomputador 4 | 5 | class TestMicrocomputador(unittest.TestCase): 6 | 7 | def teste_deve_criar_um_microcomputador(self): 8 | micro = Microcomputador(codigo_implementacao=9, descricao='oi', capacidade_do_hd=500, quantidade_de_ram=2, estacao=1) 9 | micro.codigo_implementacao |should| equal_to(9) 10 | micro.descricao |should| equal_to('oi') 11 | micro.capacidade_do_hd |should| equal_to(500) 12 | micro.quantidade_de_ram |should| equal_to(2) 13 | micro.estacao |should| equal_to(1) 14 | 15 | 16 | if __name__ == "__main__": 17 | unittest.main() 18 | -------------------------------------------------------------------------------- /impressora.py: -------------------------------------------------------------------------------- 1 | # encoding: utf-8 2 | 3 | from servidor import Servidor 4 | 5 | class Impressora(object): 6 | 7 | def __init__(self, codigo_patrimonio, descricao, velocidade): 8 | self.codigo_patrimonio = codigo_patrimonio 9 | self.descricao = descricao 10 | self.velocidade = velocidade 11 | self.fila_de_impressao = [] 12 | 13 | def conectar_ao_servidor(self): 14 | for servidor in Servidor.servidores: 15 | if servidor.impressoras_conectadas < 3: 16 | servidor.impressoras_conectadas += 1 17 | break 18 | else: 19 | raise ErroConexao('Não há servidores disponíveis!') 20 | 21 | class ErroConexao(Exception): 22 | pass 23 | -------------------------------------------------------------------------------- /teste_servidor.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from servidor import Servidor 4 | 5 | class TestServidor(unittest.TestCase): 6 | 7 | def teste_deve_criar_um_servidor(self): 8 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 9 | servidor.codigo_implementacao |should| equal_to(10) 10 | servidor.descricao |should| equal_to('oi') 11 | servidor.capacidade_do_hd |should| equal_to(5) 12 | servidor.quantidade_de_ram |should| equal_to(8) 13 | servidor.estacao |should| equal_to(1) 14 | servidor.quantidade_maxima_de_buffer |should| equal_to(10) 15 | 16 | def teste_deve_criar_uma_lista_de_servidores(self): 17 | servidor2 = Servidor(codigo_implementacao=11, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 18 | Servidor.servidores |should| have(2).itens 19 | 20 | if __name__ == "__main__": 21 | unittest.main() 22 | 23 | -------------------------------------------------------------------------------- /usuario.py: -------------------------------------------------------------------------------- 1 | #encoding: utf-8 2 | 3 | from datetime import datetime 4 | from conexao import Conexao 5 | from impressora import ErroConexao 6 | 7 | class Usuario(object): 8 | 9 | def __init__(self, nome_de_guerra, senha): 10 | self.nome_de_guerra = nome_de_guerra 11 | self.senha = senha 12 | self.esta_conectado = False 13 | 14 | def conectar(self): 15 | data = "%d/%d/%d" %(datetime.today().day, datetime.today().month, datetime.today().year) 16 | hora = "%d:%d" %(datetime.today().hour, datetime.today().minute) 17 | self.conexao = Conexao(self.nome_de_guerra, data=data, hora_inicio=hora) 18 | self.esta_conectado = True 19 | 20 | def enviar_arquivo(self, arquivo_enviado, copias): 21 | if self.esta_conectado == False: 22 | raise ErroConexao('Usuário não conectado!') 23 | else: 24 | if arquivo_enviado.nome in self.conexao.arquivos_enviados.keys(): 25 | self.conexao.arquivos_enviados[arquivo_enviado.nome] += copias 26 | else: 27 | self.conexao.arquivos_enviados.update({arquivo_enviado.nome: copias}) 28 | -------------------------------------------------------------------------------- /teste_arquivo.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from arquivo import Arquivo 4 | from usuario import Usuario 5 | from impressora import Impressora 6 | 7 | class TestArquivo(unittest.TestCase): 8 | 9 | def teste_deve_criar_um_usuario(self): 10 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 11 | usuario.nome_de_guerra |should| equal_to('@usuario') 12 | usuario.senha |should| equal_to('senha') 13 | 14 | def teste_deve_criar_uma_impressora(self): 15 | impressora = Impressora(10, 'impressora', 100) 16 | impressora.codigo_patrimonio |should| equal_to(10) 17 | impressora.descricao |should| equal_to('impressora') 18 | impressora.velocidade |should| equal_to(100) 19 | 20 | def teste_deve_criar_um_arquivo(self): 21 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 22 | impressora = Impressora(10, 'impressora', 100) 23 | arquivo = Arquivo(nome='file', proprietario=usuario, impressora_destino=impressora) 24 | arquivo.nome |should| equal_to('file') 25 | arquivo.proprietario.nome_de_guerra |should| equal_to('@usuario') 26 | arquivo.impressora_destino.codigo_patrimonio |should| equal_to(10) 27 | 28 | if __name__ == "__main__": 29 | unittest.main() 30 | 31 | -------------------------------------------------------------------------------- /teste_usuario.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from usuario import Usuario 4 | from conexao import Conexao 5 | from arquivo import Arquivo 6 | from impressora import Impressora 7 | from servidor import Servidor 8 | 9 | class TestUsuario(unittest.TestCase): 10 | 11 | def teste_deve_criar_um_usuario(self): 12 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 13 | usuario.nome_de_guerra |should| equal_to('@usuario') 14 | usuario.senha |should| equal_to('senha') 15 | usuario.esta_conectado |should| equal_to(False) 16 | 17 | def teste_usuario_deve_se_conectar(self): 18 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 19 | usuario.esta_conectado |should| equal_to(False) 20 | usuario.conectar() 21 | usuario.esta_conectado |should| equal_to(True) 22 | usuario.conexao |should| be_instance_of(Conexao) 23 | 24 | def teste_usuario_deve_enviar_arquivo(self): 25 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 26 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 27 | impressora = Impressora(10, 'impressora', 100) 28 | impressora.conectar_ao_servidor() 29 | arquivo = Arquivo(nome='file', proprietario=usuario, impressora_destino=impressora) 30 | usuario.conectar() 31 | usuario.enviar_arquivo(arquivo, 1) 32 | usuario.conexao.arquivos_enviados |should| equal_to({arquivo.nome: 1}) 33 | 34 | def teste_usuario_deve_enviar_duas_copias(self): 35 | usuario = Usuario(nome_de_guerra='@usuario', senha='senha') 36 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 37 | impressora = Impressora(10, 'impressora', 100) 38 | impressora.conectar_ao_servidor() 39 | arquivo = Arquivo(nome='file', proprietario=usuario, impressora_destino=impressora) 40 | usuario.conectar() 41 | usuario.enviar_arquivo(arquivo, 1) 42 | usuario.enviar_arquivo(arquivo, 1) 43 | usuario.conexao.arquivos_enviados |should| equal_to({arquivo.nome: 2}) 44 | 45 | 46 | 47 | if __name__ == "__main__": 48 | unittest.main() 49 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | Uma firma que utiliza equipamentos de informática necessita de um sistema que gerencie a sua rede de microcomputadores (ponto-a-ponto, não existe servidor da rede), controlando usuários, máquinas e impressoras. A rede é composta de servidores de impressão, estações e impressoras. O sistema também irá controlar a partir de qual estação o usuário está conectado a rede, e os seus arquivos enviados para impressão. 2 | Para todos os micros deseja-se cadastrar: código do patrimônio, descrição, capacidade do disco rígido, quantidade de memória e, sendo uma estação a sua localização, sendo um servidor o tamanho máximo do buffer e a quantidade máxima de buffers de impressão e que ele suporta, e as impressoras ligadas a ele (no máximo 3), caso existam. Para impressoras deseja-se cadastrar: código do patrimônio, descrição, velocidade (CPS) e, consequentemente, o servidor a que está ligada. Nesta firma todas as impressoras estão ligadas a algum servidor, não sendo compartilhada por mais de um servidor. 3 | Para controlar os usuários, o sistema só precisa do nome de guerra e senha de cada um. Como os usuários não possuem máquina fixa, a sua conexão à rede pode ocorrer a partir de qualquer estação. Tendo o usuário uma conexão ativa, o sistema não permitirá que ele se conecte a partir de outra estação. Há interesse em controlar apenas as conexões ativas (as conexões desfeitas são irrelevantes). 4 | No caso de impressão, o sistema deverá saber qual o arquivo, de quem ele é, e em qual impressora será impresso (atenção: somente usuários com conexão ativa e que possuem condição de enviar arquivos para impressão). É o usuário que escolhe a impressora onde ele quer que o seu arquivo seja impresso. Nada impede que usuários diferentes enviem arquivos de mesmo nome para impressão, porém (nesta firma) para o mesmo usuário isso não e possível, mesmo em impressoras diferentes. Neste caso o sistema permite alterar o número de cópias a serem impressas. Só deve ser mantido registro dos arquivos que ainda estão na fila de impressão. 5 | O sistema deverá listar, para cada impressora, os arquivos que estão aguardando impressão, com o respectivo usuário que a enviou, mesmo que o usuário não esteja mais ativo na rede. Sempre que solicitado o sistema exibirá, para cada estação, o seu código e, caso exista, o nome do usuário conectado, a data e hora início desta conexão e, se houver, nome e quantidade de cópias dos arquivos que ele enviou e que ainda estão aguardando impressão. 6 | -------------------------------------------------------------------------------- /teste_impressora.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from should_dsl import should 3 | from impressora import Impressora, ErroConexao 4 | from servidor import Servidor 5 | 6 | class TestImpressora(unittest.TestCase): 7 | 8 | def setUp(self): 9 | Servidor.servidores = [] 10 | 11 | def teste_deve_criar_uma_impressora(self): 12 | impressora = Impressora(10, 'impressora', 100) 13 | impressora.codigo_patrimonio |should| equal_to(10) 14 | impressora.descricao |should| equal_to('impressora') 15 | impressora.velocidade |should| equal_to(100) 16 | 17 | def teste_conectar_ao_servidor(self): 18 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 19 | impressora1 = Impressora(10, 'impressora', 100) 20 | impressora1.conectar_ao_servidor() 21 | servidor.impressoras_conectadas |should| equal_to(1) 22 | 23 | def teste_conectar_multiplas_impressoras_no_mesmo_servidor(self): 24 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 25 | impressora1 = Impressora(10, 'impressora', 100) 26 | impressora2 = Impressora(10, 'impressora', 100) 27 | impressora3 = Impressora(10, 'impressora', 100) 28 | impressora4 = Impressora(10, 'impressora', 100) 29 | impressora1.conectar_ao_servidor() 30 | impressora2.conectar_ao_servidor() 31 | impressora3.conectar_ao_servidor() 32 | impressora4.conectar_ao_servidor |should| throw(ErroConexao) 33 | servidor.impressoras_conectadas |should| equal_to(3) 34 | 35 | def teste_conectar_multiplas_impressoras_em_multiplos_servidores(self): 36 | servidor = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 37 | servidor2 = Servidor(codigo_implementacao=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10) 38 | impressora1 = Impressora(10, 'impressora', 100) 39 | impressora2 = Impressora(10, 'impressora', 100) 40 | impressora3 = Impressora(10, 'impressora', 100) 41 | impressora4 = Impressora(10, 'impressora', 100) 42 | impressora5 = Impressora(10, 'impressora', 100) 43 | impressora6 = Impressora(10, 'impressora', 100) 44 | impressora1.conectar_ao_servidor() 45 | impressora2.conectar_ao_servidor() 46 | impressora3.conectar_ao_servidor() 47 | impressora4.conectar_ao_servidor() 48 | impressora5.conectar_ao_servidor() 49 | impressora6.conectar_ao_servidor() 50 | servidor.impressoras_conectadas |should| equal_to(3) 51 | servidor.impressoras_conectadas |should| equal_to(3) 52 | 53 | if __name__ == "__main__": 54 | unittest.main() 55 | 56 | --------------------------------------------------------------------------------