class ProjectorSourceFormTest(TestCase, TestMixin): """ Test class for the Projector Source Select form module """ @patch('openlp.core.lib.projector.db.init_url') def setUp(self, mocked_init_url): """ Set up anything necessary for all tests """ mocked_init_url.return_value = 'sqlite:///{}'.format(TEST_DB) self.build_settings() self.setup_application() Registry.create() # Do not try to recreate if we've already been created from a previous test if not hasattr(self, 'projectordb'): self.projectordb = ProjectorDB() # Retrieve/create a database record self.projector = self.projectordb.get_projector_by_ip(TEST1_DATA['ip']) if not self.projector: self.projectordb.add_projector(projector=Projector(**TEST1_DATA)) self.projector = self.projectordb.get_projector_by_ip( TEST1_DATA['ip']) self.projector.dbid = self.projector.id self.projector.db_item = self.projector def tearDown(self): """ Close database session. Delete all C++ objects at end so we don't segfault. """ self.projectordb.session.close() del (self.projectordb) del (self.projector) retries = 0 while retries < 5: try: if os.path.exists(TEST_DB): os.unlink(TEST_DB) break except: time.sleep(1) retries += 1 self.destroy_settings() def test_source_dict(self): """ Test that source list dict returned from sourceselectform module is a valid dict with proper entries """ # GIVEN: A list of inputs codes = [] for item in PJLINK_DEFAULT_CODES.keys(): codes.append(item) codes.sort() # WHEN: projector.sourceselectform.source_select() is called check = source_group(codes, PJLINK_DEFAULT_CODES) # THEN: return dictionary should match test dictionary self.assertEquals( check, build_source_dict(), "Source group dictionary should match test dictionary") @patch.object(QDialog, 'exec') def test_source_select_edit_button(self, mocked_qdialog): """ Test source select form edit has Ok, Cancel, Reset, and Revert buttons """ # GIVEN: Initial setup and mocks self.projector.source_available = [ '11', ] self.projector.source = '11' # WHEN we create a source select widget and set edit=True select_form = SourceSelectSingle(parent=None, projectordb=self.projectordb) select_form.edit = True select_form.exec(projector=self.projector) projector = select_form.projector # THEN: Verify all 4 buttons are available self.assertEquals( len(select_form.button_box.buttons()), 4, 'SourceSelect dialog box should have "OK", "Cancel" ' '"Rest", and "Revert" buttons available') @patch.object(QDialog, 'exec') def test_source_select_noedit_button(self, mocked_qdialog): """ Test source select form view has OK and Cancel buttons only """ # GIVEN: Initial setup and mocks self.projector.source_available = [ '11', ] self.projector.source = '11' # WHEN we create a source select widget and set edit=False select_form = SourceSelectSingle(parent=None, projectordb=self.projectordb) select_form.edit = False select_form.exec(projector=self.projector) projector = select_form.projector # THEN: Verify only 2 buttons are available self.assertEquals( len(select_form.button_box.buttons()), 2, 'SourceSelect dialog box should only have "OK" ' 'and "Cancel" buttons available')
class TestProjectorDB(TestCase): """ Test case for ProjectorDB """ @patch('openlp.core.lib.projector.db.init_url') def setUp(self, mocked_init_url): """ Set up anything necessary for all tests """ mocked_init_url.return_value = 'sqlite:///{db}'.format(db=TEST_DB) self.projector = ProjectorDB() def tearDown(self): """ Clean up """ self.projector.session.close() self.projector = None retries = 0 while retries < 5: try: if os.path.exists(TEST_DB): os.unlink(TEST_DB) break except: time.sleep(1) retries += 1 def test_find_record_by_ip(self): """ Test find record by IP """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: Search for record using IP record = self.projector.get_projector_by_ip(TEST2_DATA['ip']) # THEN: Verify proper record returned self.assertTrue(compare_data(Projector(**TEST2_DATA), record), 'Record found should have been test_2 data') def test_find_record_by_name(self): """ Test find record by name """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: Search for record using name record = self.projector.get_projector_by_name(TEST2_DATA['name']) # THEN: Verify proper record returned self.assertTrue(compare_data(Projector(**TEST2_DATA), record), 'Record found should have been test_2 data') def test_record_delete(self): """ Test record can be deleted """ # GIVEN: Record in database add_records(self.projector, [ Projector(**TEST3_DATA), ]) record = self.projector.get_projector_by_ip(TEST3_DATA['ip']) # WHEN: Record deleted self.projector.delete_projector(record) # THEN: Verify record not retrievable found = self.projector.get_projector_by_ip(TEST3_DATA['ip']) self.assertFalse(found, 'test_3 record should have been deleted') def test_record_edit(self): """ Test edited record returns the same record ID with different data """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: We retrieve a specific record record = self.projector.get_projector_by_ip(TEST1_DATA['ip']) record_id = record.id # WHEN: Data is changed record.ip = TEST3_DATA['ip'] record.port = TEST3_DATA['port'] record.pin = TEST3_DATA['pin'] record.name = TEST3_DATA['name'] record.location = TEST3_DATA['location'] record.notes = TEST3_DATA['notes'] updated = self.projector.update_projector(record) self.assertTrue(updated, 'Save updated record should have returned True') record = self.projector.get_projector_by_ip(TEST3_DATA['ip']) # THEN: Record ID should remain the same, but data should be changed self.assertEqual(record_id, record.id, 'Edited record should have the same ID') self.assertTrue(compare_data(Projector(**TEST3_DATA), record), 'Edited record should have new data') def test_source_add(self): """ Test source entry for projector item """ # GIVEN: Record entries in database projector1 = Projector(**TEST1_DATA) self.projector.add_projector(projector1) item = self.projector.get_projector_by_id(projector1.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code='11', text='First RGB source') self.projector.add_source(source) # THEN: Projector should have the same source entry item = self.projector.get_projector_by_id(item_id) self.assertTrue(compare_source(item.source_list[0], source)) def test_manufacturer_repr(self): """ Test Manufacturer.__repr__ text """ # GIVEN: Test object manufacturer = Manufacturer() # WHEN: Name is set manufacturer.name = 'OpenLP Test' # THEN: __repr__ should return a proper string self.assertEqual( str(manufacturer), '<Manufacturer(name="OpenLP Test")>', 'Manufacturer.__repr__() should have returned a proper representation string' ) def test_model_repr(self): """ Test Model.__repr__ text """ # GIVEN: Test object model = Model() # WHEN: Name is set model.name = 'OpenLP Test' # THEN: __repr__ should return a proper string self.assertEqual( str(model), '<Model(name=' "OpenLP Test" ')>', 'Model.__repr__() should have returned a proper representation string' ) def test_source_repr(self): """ Test Source.__repr__ text """ # GIVEN: Test object source = Source() # WHEN: Source() information is set source.pjlink_name = 'Test object' source.pjlink_code = '11' source.text = 'Input text' # THEN: __repr__ should return a proper string self.assertEqual( str(source), '<Source(pjlink_name="Test object", pjlink_code="11", text="Input text")>', 'Source.__repr__() should have returned a proper representation string' ) def test_projector_repr(self): """ Test Projector.__repr__() text """ # GIVEN: Test object projector = Projector() # WHEN: projector() is populated # NOTE: projector.pin, projector.other, projector.sources should all return None # projector.source_list should return an empty list projector.id = 0 projector.ip = '127.0.0.1' projector.port = PJLINK_PORT projector.name = 'Test One' projector.location = 'Somewhere over the rainbow' projector.notes = 'Not again' projector.pjlink_name = 'TEST' projector.manufacturer = 'IN YOUR DREAMS' projector.model = 'OpenLP' # THEN: __repr__ should return a proper string self.assertEqual( str(projector), '< Projector(id="0", ip="127.0.0.1", port="4352", pin="None", name="Test One", ' 'location="Somewhere over the rainbow", notes="Not again", pjlink_name="TEST", ' 'manufacturer="IN YOUR DREAMS", model="OpenLP", other="None", sources="None", ' 'source_list="[]") >', 'Projector.__repr__() should have returned a proper representation string' ) def test_projectorsource_repr(self): """ Test ProjectorSource.__repr__() text """ # GIVEN: test setup projector1 = Projector(**TEST1_DATA) self.projector.add_projector(projector1) item = self.projector.get_projector_by_id(projector1.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code='11', text='First RGB source') self.projector.add_source(source) # THEN: __repr__ should return a proper string self.assertEqual( str(source), '<ProjectorSource(id="1", code="11", text="First RGB source", projector_id="1")>', 'ProjectorSource.__repr__)_ should have returned a proper representation string' ) def test_get_projector_by_id_none(self): """ Test get_projector_by_id returns None if no db entry """ # GIVEN: Test object and data projector = self.projector # WHEN: DB search for entry not saved results = projector.get_projector_by_id(dbid=123134556409824506) # THEN: Verify return was None self.assertEqual(results, None, 'Returned results should have equaled None')
class TestProjectorDB(TestCase): """ Test case for ProjectorDB """ def setUp(self): """ Set up anything necessary for all tests """ if not hasattr(self, "projector"): with patch("openlp.core.lib.projector.db.init_url") as mocked_init_url: mocked_init_url.start() mocked_init_url.return_value = "sqlite:///%s" % tmpfile self.projector = ProjectorDB() def find_record_by_ip_test(self): """ Test find record by IP """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: Search for record using IP record = self.projector.get_projector_by_ip(TEST2_DATA.ip) # THEN: Verify proper record returned self.assertTrue(compare_data(TEST2_DATA, record), "Record found should have been test_2 data") def find_record_by_name_test(self): """ Test find record by name """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: Search for record using name record = self.projector.get_projector_by_name(TEST2_DATA.name) # THEN: Verify proper record returned self.assertTrue(compare_data(TEST2_DATA, record), "Record found should have been test_2 data") def record_delete_test(self): """ Test record can be deleted """ # GIVEN: Record in database add_records(self, [TEST3_DATA]) record = self.projector.get_projector_by_ip(TEST3_DATA.ip) # WHEN: Record deleted self.projector.delete_projector(record) # THEN: Verify record not retrievable found = self.projector.get_projector_by_ip(TEST3_DATA.ip) self.assertFalse(found, "test_3 record should have been deleted") def record_edit_test(self): """ Test edited record returns the same record ID with different data """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: We retrieve a specific record record = self.projector.get_projector_by_ip(TEST1_DATA.ip) record_id = record.id # WHEN: Data is changed record.ip = TEST3_DATA.ip record.port = TEST3_DATA.port record.pin = TEST3_DATA.pin record.name = TEST3_DATA.name record.location = TEST3_DATA.location record.notes = TEST3_DATA.notes updated = self.projector.update_projector(record) self.assertTrue(updated, "Save updated record should have returned True") record = self.projector.get_projector_by_ip(TEST3_DATA.ip) # THEN: Record ID should remain the same, but data should be changed self.assertEqual(record_id, record.id, "Edited record should have the same ID") self.assertTrue(compare_data(TEST3_DATA, record), "Edited record should have new data") def source_add_test(self): """ Test source entry for projector item """ # GIVEN: Record entries in database self.projector.add_projector(TEST1_DATA) item = self.projector.get_projector_by_id(TEST1_DATA.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code="11", text="First RGB source") self.projector.add_source(source) # THEN: Projector should have the same source entry item = self.projector.get_projector_by_id(item_id) self.assertTrue(compare_source(item.source_list[0], source))
class TestProjectorDB(TestCase): """ Test case for ProjectorDB """ def setUp(self): """ Set up anything necessary for all tests """ if not hasattr(self, 'projector'): with patch('openlp.core.lib.projector.db.init_url' ) as mocked_init_url: mocked_init_url.start() mocked_init_url.return_value = 'sqlite:///%s' % tmpfile self.projector = ProjectorDB() def find_record_by_ip_test(self): """ Test find record by IP """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: Search for record using IP record = self.projector.get_projector_by_ip(TEST2_DATA.ip) # THEN: Verify proper record returned self.assertTrue(compare_data(TEST2_DATA, record), 'Record found should have been test_2 data') def find_record_by_name_test(self): """ Test find record by name """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: Search for record using name record = self.projector.get_projector_by_name(TEST2_DATA.name) # THEN: Verify proper record returned self.assertTrue(compare_data(TEST2_DATA, record), 'Record found should have been test_2 data') def record_delete_test(self): """ Test record can be deleted """ # GIVEN: Record in database add_records(self, [ TEST3_DATA, ]) record = self.projector.get_projector_by_ip(TEST3_DATA.ip) # WHEN: Record deleted self.projector.delete_projector(record) # THEN: Verify record not retrievable found = self.projector.get_projector_by_ip(TEST3_DATA.ip) self.assertFalse(found, 'test_3 record should have been deleted') def record_edit_test(self): """ Test edited record returns the same record ID with different data """ # GIVEN: Record entries in database add_records(self, [TEST1_DATA, TEST2_DATA]) # WHEN: We retrieve a specific record record = self.projector.get_projector_by_ip(TEST1_DATA.ip) record_id = record.id # WHEN: Data is changed record.ip = TEST3_DATA.ip record.port = TEST3_DATA.port record.pin = TEST3_DATA.pin record.name = TEST3_DATA.name record.location = TEST3_DATA.location record.notes = TEST3_DATA.notes updated = self.projector.update_projector(record) self.assertTrue(updated, 'Save updated record should have returned True') record = self.projector.get_projector_by_ip(TEST3_DATA.ip) # THEN: Record ID should remain the same, but data should be changed self.assertEqual(record_id, record.id, 'Edited record should have the same ID') self.assertTrue(compare_data(TEST3_DATA, record), 'Edited record should have new data') def source_add_test(self): """ Test source entry for projector item """ # GIVEN: Record entries in database self.projector.add_projector(TEST1_DATA) item = self.projector.get_projector_by_id(TEST1_DATA.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code='11', text='First RGB source') self.projector.add_source(source) # THEN: Projector should have the same source entry item = self.projector.get_projector_by_id(item_id) self.assertTrue(compare_source(item.source_list[0], source))
class ProjectorSourceFormTest(TestCase, TestMixin): """ Test class for the Projector Source Select form module """ @patch('openlp.core.lib.projector.db.init_url') def setUp(self, mocked_init_url): """ Set up anything necessary for all tests """ mocked_init_url.return_value = 'sqlite:///{}'.format(TEST_DB) self.build_settings() self.setup_application() Registry.create() # Do not try to recreate if we've already been created from a previous test if not hasattr(self, 'projectordb'): self.projectordb = ProjectorDB() # Retrieve/create a database record self.projector = self.projectordb.get_projector_by_ip(TEST1_DATA['ip']) if not self.projector: self.projectordb.add_projector(projector=Projector(**TEST1_DATA)) self.projector = self.projectordb.get_projector_by_ip(TEST1_DATA['ip']) self.projector.dbid = self.projector.id self.projector.db_item = self.projector def tearDown(self): """ Close database session. Delete all C++ objects at end so we don't segfault. """ self.projectordb.session.close() del(self.projectordb) del(self.projector) retries = 0 while retries < 5: try: if os.path.exists(TEST_DB): os.unlink(TEST_DB) break except: time.sleep(1) retries += 1 self.destroy_settings() def test_source_dict(self): """ Test that source list dict returned from sourceselectform module is a valid dict with proper entries """ # GIVEN: A list of inputs codes = [] for item in PJLINK_DEFAULT_CODES.keys(): codes.append(item) codes.sort() # WHEN: projector.sourceselectform.source_select() is called check = source_group(codes, PJLINK_DEFAULT_CODES) # THEN: return dictionary should match test dictionary self.assertEquals(check, build_source_dict(), "Source group dictionary should match test dictionary") @patch.object(QDialog, 'exec') def test_source_select_edit_button(self, mocked_qdialog): """ Test source select form edit has Ok, Cancel, Reset, and Revert buttons """ # GIVEN: Initial setup and mocks self.projector.source_available = ['11', ] self.projector.source = '11' # WHEN we create a source select widget and set edit=True select_form = SourceSelectSingle(parent=None, projectordb=self.projectordb) select_form.edit = True select_form.exec(projector=self.projector) projector = select_form.projector # THEN: Verify all 4 buttons are available self.assertEquals(len(select_form.button_box.buttons()), 4, 'SourceSelect dialog box should have "OK", "Cancel" ' '"Rest", and "Revert" buttons available') @patch.object(QDialog, 'exec') def test_source_select_noedit_button(self, mocked_qdialog): """ Test source select form view has OK and Cancel buttons only """ # GIVEN: Initial setup and mocks self.projector.source_available = ['11', ] self.projector.source = '11' # WHEN we create a source select widget and set edit=False select_form = SourceSelectSingle(parent=None, projectordb=self.projectordb) select_form.edit = False select_form.exec(projector=self.projector) projector = select_form.projector # THEN: Verify only 2 buttons are available self.assertEquals(len(select_form.button_box.buttons()), 2, 'SourceSelect dialog box should only have "OK" ' 'and "Cancel" buttons available')
class TestProjectorDB(TestCase): """ Test case for ProjectorDB """ @patch('openlp.core.lib.projector.db.init_url') def setUp(self, mocked_init_url): """ Set up anything necessary for all tests """ mocked_init_url.return_value = 'sqlite:///{db}'.format(db=TEST_DB) self.projector = ProjectorDB() def tearDown(self): """ Clean up """ self.projector.session.close() self.projector = None retries = 0 while retries < 5: try: if os.path.exists(TEST_DB): os.unlink(TEST_DB) break except: time.sleep(1) retries += 1 def test_find_record_by_ip(self): """ Test find record by IP """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: Search for record using IP record = self.projector.get_projector_by_ip(TEST2_DATA['ip']) # THEN: Verify proper record returned self.assertTrue(compare_data(Projector(**TEST2_DATA), record), 'Record found should have been test_2 data') def test_find_record_by_name(self): """ Test find record by name """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: Search for record using name record = self.projector.get_projector_by_name(TEST2_DATA['name']) # THEN: Verify proper record returned self.assertTrue(compare_data(Projector(**TEST2_DATA), record), 'Record found should have been test_2 data') def test_record_delete(self): """ Test record can be deleted """ # GIVEN: Record in database add_records(self.projector, [Projector(**TEST3_DATA), ]) record = self.projector.get_projector_by_ip(TEST3_DATA['ip']) # WHEN: Record deleted self.projector.delete_projector(record) # THEN: Verify record not retrievable found = self.projector.get_projector_by_ip(TEST3_DATA['ip']) self.assertFalse(found, 'test_3 record should have been deleted') def test_record_edit(self): """ Test edited record returns the same record ID with different data """ # GIVEN: Record entries in database add_records(self.projector, [Projector(**TEST1_DATA), Projector(**TEST2_DATA)]) # WHEN: We retrieve a specific record record = self.projector.get_projector_by_ip(TEST1_DATA['ip']) record_id = record.id # WHEN: Data is changed record.ip = TEST3_DATA['ip'] record.port = TEST3_DATA['port'] record.pin = TEST3_DATA['pin'] record.name = TEST3_DATA['name'] record.location = TEST3_DATA['location'] record.notes = TEST3_DATA['notes'] updated = self.projector.update_projector(record) self.assertTrue(updated, 'Save updated record should have returned True') record = self.projector.get_projector_by_ip(TEST3_DATA['ip']) # THEN: Record ID should remain the same, but data should be changed self.assertEqual(record_id, record.id, 'Edited record should have the same ID') self.assertTrue(compare_data(Projector(**TEST3_DATA), record), 'Edited record should have new data') def test_source_add(self): """ Test source entry for projector item """ # GIVEN: Record entries in database projector1 = Projector(**TEST1_DATA) self.projector.add_projector(projector1) item = self.projector.get_projector_by_id(projector1.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code='11', text='First RGB source') self.projector.add_source(source) # THEN: Projector should have the same source entry item = self.projector.get_projector_by_id(item_id) self.assertTrue(compare_source(item.source_list[0], source)) def test_manufacturer_repr(self): """ Test Manufacturer.__repr__() text """ # GIVEN: Test object manufacturer = Manufacturer() # WHEN: Name is set manufacturer.name = 'OpenLP Test' # THEN: __repr__ should return a proper string self.assertEqual(str(manufacturer), '<Manufacturer(name="OpenLP Test")>', 'Manufacturer.__repr__() should have returned a proper representation string') def test_model_repr(self): """ Test Model.__repr__() text """ # GIVEN: Test object model = Model() # WHEN: Name is set model.name = 'OpenLP Test' # THEN: __repr__ should return a proper string self.assertEqual(str(model), '<Model(name='"OpenLP Test"')>', 'Model.__repr__() should have returned a proper representation string') def test_source_repr(self): """ Test Source.__repr__() text """ # GIVEN: Test object source = Source() # WHEN: Source() information is set source.pjlink_name = 'Test object' source.pjlink_code = '11' source.text = 'Input text' # THEN: __repr__ should return a proper string self.assertEqual(str(source), '<Source(pjlink_name="Test object", pjlink_code="11", text="Input text")>', 'Source.__repr__() should have returned a proper representation string') def test_projector_repr(self): """ Test Projector.__repr__() text """ # GIVEN: Test object projector = Projector() # WHEN: projector() is populated # NOTE: projector.pin, projector.other, projector.sources should all return None # projector.source_list should return an empty list projector.id = 0 projector.ip = '127.0.0.1' projector.port = PJLINK_PORT projector.name = 'Test One' projector.location = 'Somewhere over the rainbow' projector.notes = 'Not again' projector.pjlink_name = 'TEST' projector.manufacturer = 'IN YOUR DREAMS' projector.model = 'OpenLP' # THEN: __repr__ should return a proper string self.assertEqual(str(projector), '< Projector(id="0", ip="127.0.0.1", port="4352", pin="None", name="Test One", ' 'location="Somewhere over the rainbow", notes="Not again", pjlink_name="TEST", ' 'manufacturer="IN YOUR DREAMS", model="OpenLP", other="None", sources="None", ' 'source_list="[]") >', 'Projector.__repr__() should have returned a proper representation string') def test_projectorsource_repr(self): """ Test ProjectorSource.__repr__() text """ # GIVEN: test setup projector1 = Projector(**TEST1_DATA) self.projector.add_projector(projector1) item = self.projector.get_projector_by_id(projector1.id) item_id = item.id # WHEN: A source entry is saved for item source = ProjectorSource(projector_id=item_id, code='11', text='First RGB source') self.projector.add_source(source) # THEN: __repr__ should return a proper string self.assertEqual(str(source), '<ProjectorSource(id="1", code="11", text="First RGB source", projector_id="1")>', 'ProjectorSource.__repr__)_ should have returned a proper representation string') def test_get_projector_by_id_none(self): """ Test get_projector_by_id() returns None if no db entry """ # GIVEN: Test object and data projector = self.projector # WHEN: DB search for entry not saved results = projector.get_projector_by_id(dbid=123134556409824506) # THEN: Verify return was None self.assertEqual(results, None, 'Returned results should have equaled None') def test_get_projector_all_none(self): """ Test get_projector_all() with no projectors in db """ # GIVEN: Test object with no data projector = self.projector # WHEN: We retrieve the database entries results = projector.get_projector_all() # THEN: Verify results is None self.assertEqual(results, [], 'Returned results should have returned an empty list') def test_get_projector_all_one(self): """ Test get_projector_all() with one entry in db """ # GIVEN: One entry in database projector = Projector(**TEST1_DATA) self.projector.add_projector(projector) # WHEN: We retrieve the database entries results = self.projector.get_projector_all() # THEN: We should have a list with one entry self.assertEqual(len(results), 1, 'Returned results should have returned a list with one entry') self.assertTrue((projector in results), 'Result should have been equal to TEST1_DATA') def test_get_projector_all_many(self): """ Test get_projector_all() with multiple entries in db """ # GIVEN: multiple entries in database projector_list = [] projector_list.append(Projector(**TEST1_DATA)) projector_list.append(Projector(**TEST2_DATA)) projector_list.append(Projector(**TEST3_DATA)) for projector in projector_list: self.projector.add_projector(projector) # WHEN: We retrieve the database entries results = self.projector.get_projector_all() # THEN: We should have a list with three entries self.assertEqual(len(results), len(projector_list), 'Returned results should have returned a list with three entries') for projector in results: self.assertTrue((projector in projector_list), 'Projector DB entry should have been in expected list') def test_get_projector_by_name_fail(self): """ Test get_projector_by_name() fail """ # GIVEN: Test entry in database self.projector.add_projector(Projector(**TEST1_DATA)) # WHEN: We attempt to get a projector that's not in database results = self.projector.get_projector_by_name(name=TEST2_DATA['name']) # THEN: We should have None self.assertEqual(results, None, 'projector.get_projector_by_name() should have returned None') def test_add_projector_fail(self): """ Test add_projector() fail """ # GIVEN: Test entry in the database ignore_result = self.projector.add_projector(Projector(**TEST1_DATA)) # WHEN: Attempt to add same projector entry results = self.projector.add_projector(Projector(**TEST1_DATA)) # THEN: We should have failed to add new entry self.assertFalse(results, 'add_projector() should have failed') def test_update_projector_default_fail(self): """ Test update_projector() with no options fails """ # GIVEN: projector instance projector = self.projector # WHEN: attempt to update a projector entry with no options results = projector.update_projector() # THEN: We should have failed self.assertFalse(results, 'update_projector(projector=None) should have returned False') def test_update_projector_not_in_db_fail(self): """ Test update_projector() when entry not in database """ # GIVEN: Projector entry in database ignore_result = self.projector.add_projector(Projector(**TEST1_DATA)) projector = Projector(**TEST2_DATA) # WHEN: Attempt to update data with a different ID results = self.projector.update_projector(projector) # THEN: Results should be False self.assertFalse(results, 'update_projector(projector=projector) should have returned False') def test_delete_projector_fail(self): """ Test delete_projector(projector) fails to delete record """ # GIVEN: Test entry in db self.projector.add_projector(Projector(**TEST1_DATA)) # wHEN: Attempting to delete an entry not in the databae results = self.projector.delete_projector(Projector(**TEST2_DATA)) # THEN: Results should be False self.assertFalse(results, 'delete_projector() should have returned False')