def setUp(self):
     self.case = GeneLocationUploader()
class GeneLocationUploaderTestCase(unittest.TestCase):
    def setUp(self):
        self.case = GeneLocationUploader()

    @classmethod
    def setUpClass(cls):
        super(GeneLocationUploaderTestCase, cls).setUpClass()
        cls.setupBlazegraph()

    @classmethod
    def setupBlazegraph(cls):
        """
        Sets up some data for testing methods in this class that queries Blazegraph.
        Assumes that Blazegraph is initially empty when testing.
        """
        g = Graph()
        g.add((n.agn43_AP009048_closed_0, rdf.type, faldo.Region))
        g.add((n.agn43_AP009048_closed_0, rdf.type, n.reference_gene))
        g.add((n.agn43_AP009048_closed_0, n.is_gene_of, n.AP009048))
        g.add((n.agn43_AP009048_closed_0, n.has_sequence, Literal("ACGTTGCA", datatype=XSD.string)))
        g.add((n.agn43, n.has_copy, n.agn43_AP009048_closed_0))
        g.add((n.agn43_AP009048_closed_0_begin, faldo.position, Literal("2073676", datatype=XSD.string)))
        g.add((n.agn43_AP009048_closed_0_end, faldo.position, Literal("2076795", datatype=XSD.string)))
        g.add((n.agn43_AP009048_closed_0, faldo.begin, n.agn43_AP009048_closed_0_begin))
        g.add((n.agn43_AP009048_closed_0, faldo.end, n.agn43_AP009048_closed_0_end))
        g.add((n.agn43, n.has_copy, n.agn43_AP009048_closed_0))
        g.add((n.AP009048, n.has_gene, n.agn43_AP009048_closed_0))

        g.add((n.ecpC_CP002729_closed_0, rdf.type, faldo.Region))
        g.add((n.ecpC_CP002729_closed_0, n.has_sequence, Literal("ACGTTGCA", datatype=XSD.string)))
        g.add((n.ecpC, n.has_copy, n.ecpC_CP002729_closed_0))
        g.add((n.CP002729, n.has_gene, n.ecpC_CP002729_closed_0))

        BlazegraphUploader().upload_data(generate_output(g))

        del g

    def tearDown(self):
        del self.case

    def test_get_accession_name(self):
        ## Non-complete genome
        contig = "ANVW00000000"
        desc = "a description"

        returned_string = self.case.get_accession_name(contig, desc)
        self.assertEqual(returned_string, "ANVW00000000")

        ## Complete genome
        contig = "CP102000"
        desc = "a complete genome"
        returned_string = self.case.get_accession_name(contig, desc)
        self.assertEqual(returned_string, "CP102000_closed")


    @mock.patch('superphy.upload.gene_location_upload.GeneLocationUploader.get_num_gene_copies')
    def test_add_contig(self, mock_copies):
        ## Adding a location to an existing gene with existing contig
        self.case.dict = {"hlyA":{"ANVW01000001":0}}
        self.case.add_contig("hlyA", "ANVW01000001")
        self.assertEqual(self.case.dict, {"hlyA":{"ANVW01000001":1}})

        ## Adding location to an existing gene with non-existing contig
        mock_copies.return_value = 0
        self.case.add_contig("hlyA", "JPQG01000001")
        self.assertEqual(self.case.dict, {"hlyA":{"ANVW01000001":1, "JPQG01000001": 0}})

        ## Adding location w/ non-existing genome and contig
        self.case.add_contig("espF", "JPQG01000002")
        self.assertEqual(self.case.dict, {"hlyA":{"ANVW01000001":1, "JPQG01000001": 0}, 
                                          "espF":{"JPQG01000002": 0}})

        ## Adding location w/ exisitng genome and contig in Blazegraph (but not the dict)
        mock_copies.reset_mock()
        mock_copies.return_value = 4
        self.case.add_contig("aafA", "JPQG01000001")
        self.assertEqual(self.case.dict, {"hlyA":{"ANVW01000001":1, "JPQG01000001": 0}, 
                                          "espF":{"JPQG01000002": 0},
                                          "aafA":{"JPQG01000001": 4}})

    
    def test_get_num_gene_copies(self):
        self.assertEqual(self.case.get_num_gene_copies("agn43", "AP009048"), 1)
        self.assertEqual(self.case.get_num_gene_copies("espF", "ANVW01000001"), 0)


    @mock.patch('superphy.upload.gene_location_upload.BlazegraphUploader', autospec=True)
    @mock.patch('superphy.upload.gene_location_upload.Graph')
    @mock.patch('superphy.upload.gene_location_upload.GeneLocation')
    @mock.patch('superphy.upload.gene_location_upload.GeneLocationUploader.check_gene_copy')
    def test_create_gene_location(self, mock_check, mock_rdf, mock_graph, mock_bg):
        mock_check.return_value = False
        mock_genelocation = mock.MagicMock(spec=GeneLocation, create=True)
        mock_g = mock.MagicMock(spec=Graph, create=True)
        mock_graph.return_value = mock_g
        mock_rdf.return_value = mock_genelocation
        self.case.create_gene_location("name", "gene", "contig", "begin", "end", "seq", "ref_gene", None)

        self.assertEqual(len(mock_check.mock_calls), 1)
        mock_rdf.assert_called_once_with(mock_g, "name", "gene", "contig", "begin", "end", "seq", "ref_gene", None)
        mock_bg.assert_called_once_with()


    def test_check_gene_copy(self):
        """
        Assumes that there is no data uploaded to Blazegraph before executing these tests.
        """
        self.assertTrue(self.case.check_gene_copy("agn43", "AP009048", "2073676", "2076795"))