def __init__(self): with\ Autowired('DbTestData', singleton=False) as DbTestData,\ Autowired('Config', singleton=False) as Config: self.TRAIN_SET_VALUES = numpy.array(list(DbTestData.trainComments)) self.PROBLEM_OIDS = numpy.array(list(DbTestData.problemOids)) self.TRAIN_SET = pandas.read_csv(Config.TRAINING_SET_FILE, '\t', encoding='utf-8', names=Config.TRAINING_SET_COLUMNS) self.PROBLEM_SET = pandas.read_csv( Config.PROBLEM_SET_FILE, '\t', encoding='utf-8', names=Config.PROBLEM_SET_COLUMNS) self.PROBLEM_SET_VALUES = numpy.array( list(DbTestData.problemComments)) self.MAX_LENGTH = 6 self.OUTPUT_NEURONS = 4 self.TRAIN_RESULTS = numpy.array([ 2, 3, 3, 1, ]) self.PROBLEM_MODEL_INPUT = [[98, 111, 111, 0, 0, 0], [102, 101, 102, 101, 102, 101]] self.TRAIN_MODEL_INPUT = [[98, 108, 97, 98, 108, 97], [98, 101, 101, 97, 0, 0], [98, 101, 97, 97, 0, 0], [98, 97, 122, 0, 0, 0]] self.PROBLEM_MODEL_RESULT = [[0.3, 0.1, 0.6, 0], [0, 0.3, 0.1, 0.6]]
def setUp(self): with Autowired('WinterBootTestData', self): if self.WinterBootTestData.undefinedConsumedServiceId in consumers: del consumers[ self.WinterBootTestData.undefinedConsumedServiceId] import testpackage autoload(testpackage) Autowired(self.WinterBootTestData.undefinedConsumedServiceId)
def testdisplayTransaction_prints_the_transaction(self): with\ Autowired('UiTestData',self),\ Autowired('AiTestData',self),\ unittest.mock.patch('sys.stdout') as mockedStdout: displayAccuracyService.call(self.AiTestData.ACCURACY) TestHelper.assertPrintedOn( mockedStdout, self.UiTestData.ACCURACY_STRING.format(self.AiTestData.ACCURACY))
def setUp(self): with \ Autowired('DataTestData', self),\ Autowired('AiTestData', self),\ Autowired('UpdateTestData', self),\ MockedService('PrepareDataService', self),\ MockedService('NeuralNetBuilderService', self),\ MockedService('NeuralNetTrainerService', self),\ MockedService('AccuracyCheckService', self),\ MockedService('UpdateService', self): categorizerService.call()
def setUp(self): with \ Autowired('UpdateTestData', self),\ Autowired('DbTestData', self),\ MockedService('RowUpdateService', self),\ MockedService('ConnectionService', self),\ MockedService('CategoryService', self): updateService.call(self.UpdateTestData.data) self.handleOneRowArgs = self.RowUpdateService.call
def setUp(self): with \ Autowired('DbTestData', self),\ unittest.mock.patch('psycopg2.connect', new = self.DbTestData.connector) as connector: self.fakeConnection = self.DbTestData.connection self.connector = connector self.connection = connectionService.call()
def setUp(self): with Autowired('DbTestData', self, singleton=False): self.fakeConnection = self.DbTestData.connection updateDBService.call(self.fakeConnection, self.DbTestData.oidAsString, self.DbTestData.fetched_row, self.DbTestData.choice)
def setUp(self): with\ Autowired('DataTestData',self),\ MockedService('NumericConverterService', self): self.result = prepareDataService.call( self.DataTestData.TRAIN_SET, self.DataTestData.PROBLEM_SET) self.callList = self.NumericConverterService.call.mock_calls
def setUp(self): with Autowired('UpdateTestData') as testData: self.existingChoice = testData.existingChoice self.nonExistingChoice = testData.nonExistingChoice self.regexConformantChoiceInput = testData.regexConformantChoiceInput self.choiceFromRegexConformantInput = testData.choiceFromRegexConformantInput self.regexConformantChoiceInput = testData.regexConformantChoiceInput self.regexConformantChoiceInput = testData.regexConformantChoiceInput self.options = testData.PREPARED_OPTIONS
def setUp(self): with Autowired('AiTestData', self, singleton=False): self.model = self.AiTestData.model self.result = neuralNetTrainerService.call( self.AiTestData.TRAIN_VALUES, self.AiTestData.TRAIN_RESULTS, self.model) self.compileCallKwargs = TestHelper.callKwArgument( self.model.compile) self.fitCallKwargs = TestHelper.callKwArgument(self.model.fit)
def test_displayOption_displays_choice_number_probability_and_categories( self): with\ Autowired('UpdateTestData', self),\ unittest.mock.patch('sys.stdout') as mockedStdout: optionDisplayService.call( self.UpdateTestData.resultKeys[0], self.UpdateTestData.data.problemValues[0][2], self.UpdateTestData.categories[3]) TestHelper.assertPrintedOn(mockedStdout, self.UpdateTestData.outputOfFirstOption)
def setUp(self): with\ Autowired('DataTestData', self),\ MockedService('keras.Sequential') as self.model: self.result = neuralNetBuilderService().call(self.DataTestData.MAX_LENGTH, self.DataTestData.OUTPUT_NEURONS ) self.firstCallList = TestHelper.callArgument(self.model, 0)
#coding=utf-8 import unittest from winterboot.Autowired import Autowired import keras import tensorflow import TestHelper from winterboot.MockedService import MockedService neuralNetBuilderService = Autowired('NeuralNetBuilderService') config = Autowired('Config')() class testNeuralNetBuilderService(unittest.TestCase): def setUp(self): with\ Autowired('DataTestData', self),\ MockedService('keras.Sequential') as self.model: self.result = neuralNetBuilderService().call(self.DataTestData.MAX_LENGTH, self.DataTestData.OUTPUT_NEURONS ) self.firstCallList = TestHelper.callArgument(self.model, 0) def test_it_builds_a_Sequential_model(self): self.model.assert_called_once() def test_first_layer_is_Dense(self): self.assertEqual(keras.layers.Dense, type(self.firstCallList[0])) def test_first_layer_have_FIRST_LAYER_NEURONS_number_of_neurons(self): self.assertEqual(config.FIRST_LAYER_NEURONS, self.firstCallList[0].units) def test_first_layer_have_relu_activation(self): self.assertEqual(tensorflow.nn.relu, self.firstCallList[0].activation) def test_second_layer_is_Dense(self): self.assertEqual(keras.layers.Dense, type(self.firstCallList[1])) def test_second_layer_have_SECOND_LAYER_NEURONS_number_of_neurons(self):
from winterboot.Autowired import Autowired from winterboot.Service import Service from categorizerai.ai.AIData import AIData connectionService = Autowired('ConnectionService') categoryService = Autowired('CategoryService') rowUpdateService = Autowired('RowUpdateService') @Service class UpdateService: def call(self, data: AIData) -> None: connection = connectionService.call() categories = categoryService.call(connection) for rowNumber in range(len(data.problemResults)): rowUpdateService.call(rowNumber, data, connection, categories) connection.close()
import unittest from winterboot.Autowired import Autowired import TestHelper optionDisplayService = Autowired('OptionDisplayService') class Test(unittest.TestCase): def test_displayOption_displays_choice_number_probability_and_categories( self): with\ Autowired('UpdateTestData', self),\ unittest.mock.patch('sys.stdout') as mockedStdout: optionDisplayService.call( self.UpdateTestData.resultKeys[0], self.UpdateTestData.data.problemValues[0][2], self.UpdateTestData.categories[3]) TestHelper.assertPrintedOn(mockedStdout, self.UpdateTestData.outputOfFirstOption) if __name__ == "__main__": unittest.main()
import unittest from winterboot.Autowired import Autowired import TestHelper displayAccuracyService = Autowired("DisplayAccuracyService") class Test(unittest.TestCase): def testdisplayTransaction_prints_the_transaction(self): with\ Autowired('UiTestData',self),\ Autowired('AiTestData',self),\ unittest.mock.patch('sys.stdout') as mockedStdout: displayAccuracyService.call(self.AiTestData.ACCURACY) TestHelper.assertPrintedOn( mockedStdout, self.UiTestData.ACCURACY_STRING.format(self.AiTestData.ACCURACY)) if __name__ == "__main__": unittest.main()
#!/usr/bin/python3 #coding=utf-8 import pandas from winterboot.Autowired import Autowired from winterboot.Service import Service config = Autowired('Config')() prepareDataService = Autowired('PrepareDataService') neuralNetBuilderService = Autowired('NeuralNetBuilderService') neuralNetTrainerService = Autowired('NeuralNetTrainerService') accuracyCheckService = Autowired('AccuracyCheckService') updateService = Autowired('UpdateService') @Service class CategorizerService(object): def call(self) -> None: trainSet = pandas.read_csv(config.TRAINING_SET_FILE,'\t',encoding='utf-8',names=config.TRAINING_SET_COLUMNS) problemSet = pandas.read_csv(config.PROBLEM_SET_FILE,'\t',encoding='utf-8',names=config.PROBLEM_SET_COLUMNS) data = prepareDataService.call(trainSet, problemSet) model = neuralNetBuilderService.call(data.max_length, data.numberOfOutputNeurons) accuracy = neuralNetTrainerService.call(data.trainValues, data.trainResults, model) accuracyCheckService.call(accuracy) data.problemResults=model.predict(data.problemValues) updateService.call(data)
from winterboot.Autowired import Autowired from winterboot.Service import Service from categorizerai.ai.AIData import AIData import psycopg2 rowProviderService = Autowired('RowProviderService') transactionDisplayService = Autowired('TransactionDisplayService') updateDBService = Autowired('UpdateDBService') optionPreparatorService = Autowired('OptionPreparatorService') choiceObtainerService = Autowired('ChoiceObtainerService') @Service class RowUpdateService: def call(self, rowNumber: int, data: AIData, connection: psycopg2.extensions.connection, categories: tuple) -> None: oidAsStr = str(data.problemOids[rowNumber]) row = rowProviderService.call(connection, oidAsStr) transactionDisplayService.call(row) options = optionPreparatorService.call(rowNumber, data, categories) choice = choiceObtainerService.call(options) if choice is not None: updateDBService.call(connection, oidAsStr, row, choice)
import unittest from winterboot.Autowired import Autowired from winterboot.MockedService import MockedService import TestHelper choiceAskService = Autowired("ChoiceAskService") class Test(unittest.TestCase): def setUp(self): with\ Autowired('UiTestData', self),\ MockedService('categorizerai.ui.ChoiceAskService.input') as self.mockedInput: self.answer = choiceAskService.call() def test_askUserForChoice_displays_prompt(self): TestHelper.assertCallParameter(self.UiTestData.PROMPT, self.mockedInput, 0) def test_askUserForChoice_returns_value_given_in_stdin(self): self.assertEqual(self.UiTestData.ANSWER_TO_CHOICE_PROMPT, self.answer) if __name__ == "__main__": unittest.main()
from winterboot.Autowired import Autowired from winterboot.Service import Service import types config = Autowired('Config')() @Service class UpdateDBService: def call(self, connection, oid, row, choice): table = config.figureOutTable(row) sentence = self._createUpdateSentence(oid, choice, table) cursor = connection.cursor() cursor.execute(sentence) connection.commit() cursor.close() def _createUpdateSentence(self, oid, choice, table): args = types.SimpleNamespace() args.table = table args.choice = choice args.oid = oid sentence = config.SQL_TO_UPDATE_RECORD.format(args) return sentence
#coding=utf-8 import unittest from winterboot.Autowired import Autowired import TestHelper categoryService = Autowired('CategoryService') config = Autowired('Config')() class Test(unittest.TestCase): def setUp(self): with Autowired('DbTestData', self, singleton=False): self.fakeConnection = self.DbTestData.connection self.categories = categoryService.call(self.fakeConnection) def test_returns_a_dict_keyed_with_the_element_ID_COLUMN_POSITION_IN_CATEGORIES_TABLE( self): firstRow = self.DbTestData.all_rows[0] firstRowKey = firstRow[config.ID_COLUMN_POSITION_IN_CATEGORIES_TABLE] self.assertEqual(firstRow, self.categories[firstRowKey]) def test_the_returned_dict_contains_elements_for_all_different_keys(self): self.assertEqual(len(self.DbTestData.all_rows), len(self.categories)) def test_closes_the_connection(self): self.fakeConnection.cursor.assert_called_once() def test_executes_SQL_TO_OBTAIN_CATEGORIES(self): self.fakeConnection.cursor.execute.assert_called_once() TestHelper.assertCallParameter(config.SQL_TO_OBTAIN_CATEGORIES, self.fakeConnection.cursor.execute, 0)
#coding=utf-8 import unittest from winterboot.Autowired import Autowired import TestHelper neuralNetTrainerService = Autowired('NeuralNetTrainerService') config = Autowired('Config')() class Test(unittest.TestCase): def setUp(self): with Autowired('AiTestData', self, singleton=False): self.model = self.AiTestData.model self.result = neuralNetTrainerService.call( self.AiTestData.TRAIN_VALUES, self.AiTestData.TRAIN_RESULTS, self.model) self.compileCallKwargs = TestHelper.callKwArgument( self.model.compile) self.fitCallKwargs = TestHelper.callKwArgument(self.model.fit) def test_trainNeuralNet_compiles_the_model(self): self.model.compile.assert_called_once() def test_trainNeuralNet_returns_model_accuracy(self): self.assertEqual(self.AiTestData.ACCURACY, self.result) def test_loss_funtions_is_sparse_categorical_crossentropy(self): self.assertEqual("sparse_categorical_crossentropy", self.compileCallKwargs['loss'])
import unittest from winterboot.Autowired import Autowired from winterboot.MockedService import MockedService import TestHelper updateService = Autowired("UpdateService") class Test(unittest.TestCase): def setUp(self): with \ Autowired('UpdateTestData', self),\ Autowired('DbTestData', self),\ MockedService('RowUpdateService', self),\ MockedService('ConnectionService', self),\ MockedService('CategoryService', self): updateService.call(self.UpdateTestData.data) self.handleOneRowArgs = self.RowUpdateService.call def test_handleUpdates_obtains_a_connection(self): self.ConnectionService.call.assert_called_once() def test_fetches_categories_using_the_connection(self): self.CategoryService.call.assert_called_once_with( self.DbTestData.connection) def test_calls_RowUpdateService_for_all_rows_in_problem_results(self): self.assertEqual(len(self.UpdateTestData.data.problemResults),
def setUp(self): with\ Autowired('UiTestData', self),\ MockedService('categorizerai.ui.ChoiceAskService.input') as self.mockedInput: self.answer = choiceAskService.call()
def answerIs(self,choice): with Autowired('ChoiceAskService', self): self.ChoiceAskService.call.return_value = choice
def test_TestData_instances_are_differ(self): TestTestData = Autowired('TestTestData') self.assertNotEqual(TestTestData(),TestTestData())
def setUp(self): with Autowired('DbTestData', self, singleton=False): self.fakeConnection = self.DbTestData.connection self.categories = categoryService.call(self.fakeConnection)
import unittest from winterboot.Autowired import Autowired from winterboot.MockedService import MockedService import TestHelper optionPreparatorService = Autowired('OptionPreparatorService') class Test(unittest.TestCase): def setUp(self): with\ Autowired('UpdateTestData', self, singleton=False),\ MockedService('OptionDisplayService', self): self.result = optionPreparatorService.call( self.UpdateTestData.rowNumber, self.UpdateTestData.data, self.UpdateTestData.categories) def test_prepareOptionsToOffer_returns_a_dict_keyed_by_small_numbers(self): self.assertEqual(self.UpdateTestData.resultKeys, list(self.result.keys())) def test_the_first_element_in_the_value_tuple_is_the_probability(self): self.assertEqual(self.UpdateTestData.data.problemValues[0][2], self.result[1][0]) def test_the_second_element_in_the_value_tuple_is_a_value_of_the_categories_dict(self): self.assertEqual(self.UpdateTestData.categories[3], self.result[1][1]) def test_prepareOptionsToOffer_displays_choice_key(self): TestHelper.assertCallParameter(self.UpdateTestData.resultKeys[0], self.OptionDisplayService.call, 0) def test_prepareOptionsToOffer_displays_probability(self): TestHelper.assertCallParameter(self.UpdateTestData.data.problemValues[0][2], self.OptionDisplayService.call, 1) def test_prepareOptionsToOffer_displays_categories(self):
def testName(self): origTestData = Autowired('TestTestData')() with TestDataForStub('TestTestData', self): self.assertEqual(origTestData, self.TestTestData)
def setUp(self): with\ Autowired('UpdateTestData', self, singleton=False),\ MockedService('OptionDisplayService', self): self.result = optionPreparatorService.call( self.UpdateTestData.rowNumber, self.UpdateTestData.data, self.UpdateTestData.categories)