Beispiel #1
0
    def testNullsAndInf(self):
        tdf = TicDatFactory(table=[["field one"], ["field two"]])
        for f in ["field one", "field two"]:
            tdf.set_data_type("table", f, nullable=True)
        dat = tdf.TicDat(
            table=[[None, 100], [200, 109], [0, 300], [300, None], [400, 0]])
        schema = test_schema + "_bool_defaults"
        tdf.pgsql.write_schema(self.engine,
                               schema,
                               include_ancillary_info=False)
        tdf.pgsql.write_data(dat, self.engine, schema)

        dat_1 = tdf.pgsql.create_tic_dat(self.engine, schema)
        self.assertTrue(tdf._same_data(dat, dat_1))

        tdf = TicDatFactory(table=[["field one"], ["field two"]])
        for f in ["field one", "field two"]:
            tdf.set_data_type("table", f, max=float("inf"), inclusive_max=True)
        tdf.set_infinity_io_flag(None)
        dat_inf = tdf.TicDat(table=[[float("inf"), 100], [200, 109], [0, 300],
                                    [300, float("inf")], [400, 0]])
        dat_1 = tdf.pgsql.create_tic_dat(self.engine, schema)

        self.assertTrue(tdf._same_data(dat_inf, dat_1))
        tdf.pgsql.write_data(dat_inf, self.engine, schema)
        dat_1 = tdf.pgsql.create_tic_dat(self.engine, schema)
        self.assertTrue(tdf._same_data(dat_inf, dat_1))

        tdf = TicDatFactory(table=[["field one"], ["field two"]])
        for f in ["field one", "field two"]:
            tdf.set_data_type("table",
                              f,
                              min=-float("inf"),
                              inclusive_min=True)
        tdf.set_infinity_io_flag(None)
        dat_1 = tdf.pgsql.create_tic_dat(self.engine, schema)
        self.assertFalse(tdf._same_data(dat_inf, dat_1))
        dat_inf = tdf.TicDat(table=[[float("-inf"), 100], [200, 109], [0, 300],
                                    [300, -float("inf")], [400, 0]])
        self.assertTrue(tdf._same_data(dat_inf, dat_1))
Beispiel #2
0
    def test_diet(self):
        if not self.can_run:
            return
        tdf = diet_schema.clone()
        tdf.set_infinity_io_flag(999999999)
        pgtf = tdf.pgsql
        pgtf.write_schema(self.engine,
                          test_schema,
                          include_ancillary_info=False)
        pgtf.write_data(diet_dat, self.engine, test_schema)
        self.assertFalse(pgtf.find_duplicates(self.engine, test_schema))
        pg_tic_dat = pgtf.create_tic_dat(self.engine, test_schema)
        self.assertTrue(diet_schema._same_data(diet_dat, pg_tic_dat))

        tdf = diet_schema.clone()
        tdf.set_infinity_io_flag(None)
        pgtf_null_inf = tdf.pgsql
        pg_tic_dat_none_inf = pgtf_null_inf.create_tic_dat(
            self.engine, test_schema)
        self.assertFalse(diet_schema._same_data(diet_dat, pg_tic_dat_none_inf))
        pg_tic_dat_none_inf.categories["protein"]["Max Nutrition"] = float(
            "inf")
        self.assertTrue(diet_schema._same_data(diet_dat, pg_tic_dat_none_inf))

        dat2 = diet_schema.copy_tic_dat(diet_dat)
        dat2.foods["za"] = dat2.foods.pop("pizza")
        pgtf.write_data(dat2,
                        self.engine,
                        test_schema,
                        pre_existing_rows={"foods": "append"})
        self.assertTrue(
            set(pgtf.find_duplicates(self.engine, test_schema)) == {'foods'})
        dat3 = pgtf.create_tic_dat(self.engine, test_schema)
        self.assertTrue(
            set(dat3.foods).issuperset(dat2.foods)
            and set(dat3.foods).issuperset(diet_dat.foods))
        self.assertTrue(set(dat3.foods).difference(diet_dat.foods) == {'za'})
        self.assertTrue(set(dat3.foods).difference(dat2.foods) == {'pizza'})

        pgtf.write_data(dat2,
                        self.engine,
                        test_schema,
                        pre_existing_rows={"nutrition_quantities": "append"})
        self.assertTrue(
            set(pgtf.find_duplicates(self.engine, test_schema)) ==
            {'nutrition_quantities'})
        dat4 = pgtf.create_tic_dat(self.engine, test_schema)
        self.assertTrue(diet_schema._same_data(dat2, dat4))

        test_schema_2 = test_schema + "_none_inf"
        pgtf_null_inf.write_schema(self.engine, test_schema_2)
        pgtf_null_inf.write_data(pg_tic_dat_none_inf, self.engine,
                                 test_schema_2)
        pg_tic_dat = pgtf.create_tic_dat(self.engine, test_schema_2)
        self.assertFalse(diet_schema._same_data(diet_dat, pg_tic_dat))
        pg_tic_dat.categories["protein"]["Max Nutrition"] = float("inf")
        self.assertTrue(diet_schema._same_data(diet_dat, pg_tic_dat))
        pg_tic_dat_none_inf = pgtf_null_inf.create_tic_dat(
            self.engine, test_schema_2)
        self.assertTrue(diet_schema._same_data(diet_dat, pg_tic_dat_none_inf))

        tdf = TicDatFactory(
            **diet_schema.schema())  # not clone so losing the data types
        tdf.set_infinity_io_flag(None)
        pgtf_null_inf = tdf.pgsql
        pg_tic_dat_none_inf = pgtf_null_inf.create_tic_dat(
            self.engine, test_schema_2)
        self.assertFalse(diet_schema._same_data(diet_dat, pg_tic_dat_none_inf))
        self.assertTrue(
            pg_tic_dat_none_inf.categories["protein"]["Max Nutrition"] is None)