def test_decimal_filters_gte(self):
valid_data = {
"integer_choice_field": 2,
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
invalid_data = {
"integer_choice_field": 2,
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
for i in range(10):
ExampleModelOneFactory(decimal_field=1 + i * 0.1, **valid_data)
for i in range(10):
ExampleModelOneFactory(decimal_field=i * 0.1, **invalid_data)
response = self.client.get(self.url + "?decimal_field=1:")
self.assertEqual(response.data["total_result_count"], 10)
for result in response.data["results"]:
self.assertTrue(Decimal(result["decimal_field"]) >= 1)
def test_date_field_fitlering_range(self):
ExampleModelOneFactory(
date_field=date(year=2018, month=1, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=2, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=3, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=4, day=1), boolean_field=True
)
response = self.client.get(self.url + "?date_field=2018-02-01:2018-04-01")
self.assertEqual(response.data["total_result_count"], 3)
self.assertIn(
"2018-02-01", [result["date_field"] for result in response.data["results"]]
)
self.assertIn(
"2018-03-01", [result["date_field"] for result in response.data["results"]]
)
self.assertIn(
"2018-04-01", [result["date_field"] for result in response.data["results"]]
)
def test_integer_filters_equal(self):
valid_data = {
"integer_field": 1,
"integer_choice_field": 2,
"float_field": 10.0,
"decimal_field": Decimal("10"),
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
invalid_data = {
"integer_field": 2,
"integer_choice_field": 2,
"float_field": 10.0,
"decimal_field": Decimal("10"),
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
ExampleModelOneFactory(**valid_data)
ExampleModelOneFactory(**invalid_data)
response = self.client.get(self.url + "?integer_field=1")
self.assertEqual(response.data["total_result_count"], 1)
self.assertEqual(response.data["results"][0]["integer_field"], 1)
def test_boolean_filter_false(self):
ExampleModelOneFactory(boolean_field=True)
ExampleModelOneFactory(boolean_field=False)
response = self.client.get(self.url + "?boolean_field=false")
self.assertEqual(response.data["total_result_count"], 1)
self.assertFalse(response.data["results"][0]["boolean_field"])
def test_foreign_key_field_filtering(self):
em2 = ExampleModelTwoFactory()
ExampleModelOneFactory(other_model=em2, boolean_field=True)
ExampleModelOneFactory(boolean_field=True)
response = self.client.get(self.url + "?other_model=" + str(em2.uuid))
self.assertEqual(response.data["total_result_count"], 1)
def test_slug_field_filter(self):
ExampleModelOneFactory(slug_field="Hooray", boolean_field=True)
ExampleModelOneFactory(slug_field="hoor", boolean_field=True)
ExampleModelOneFactory(slug_field="athoor", boolean_field=True)
ExampleModelOneFactory(slug_field="Stuff", boolean_field=True)
response = self.client.get(self.url + "?slug_field=hoor")
self.assertEqual(response.data["total_result_count"], 3)
def test_nullboolean_filter_true(self):
ExampleModelOneFactory(nullboolean_field=True, boolean_field=True)
ExampleModelOneFactory(nullboolean_field=False, boolean_field=True)
ExampleModelOneFactory(nullboolean_field=None, boolean_field=True)
response = self.client.get(self.url + "?nullboolean_field=true")
self.assertEqual(response.data["total_result_count"], 1)
self.assertTrue(response.data["results"][0]["nullboolean_field"])
def test_ordering_boolean_field_desc(self):
ExampleModelOneFactory.create(boolean_field=True)
ExampleModelOneFactory.create(boolean_field=False)
ExampleModelOneFactory.create(boolean_field=True)
ExampleModelOneFactory.create(boolean_field=False)
ExampleModelOneFactory.create(boolean_field=True)
response = self.client.get(self.url, {"_order": "-boolean_field"})
self.assertEqual(response.data["results"][4]["boolean_field"], False)
self.assertEqual(response.data["results"][3]["boolean_field"], False)
self.assertEqual(response.data["results"][2]["boolean_field"], True)
self.assertEqual(response.data["results"][1]["boolean_field"], True)
self.assertEqual(response.data["results"][0]["boolean_field"], True)
def test_many_to_many_field_filtering(self):
em2 = ExampleModelTwoFactory(name="Test Item")
valid_model = ExampleModelOneFactory(other_model=em2, boolean_field=True)
ExampleModelOneFactory(boolean_field=True)
valid_model.many_to_many_field.add(em2)
response = self.client.get(self.url + "?many_to_many_field=" + str(em2.uuid))
self.assertEqual(response.data["total_result_count"], 1)
self.assertEqual(
response.data["results"][0]["many_to_many_field"], ["Test Item"]
)
def test_ordering_integer_field_desc(self):
ExampleModelOneFactory.create(integer_field=4)
ExampleModelOneFactory.create(integer_field=5)
ExampleModelOneFactory.create(integer_field=3)
ExampleModelOneFactory.create(integer_field=1)
ExampleModelOneFactory.create(integer_field=2)
response = self.client.get(self.url, {"_order": "-integer_field"})
self.assertEqual(response.data["total_result_count"], 5)
self.assertEqual(response.data["results"][0]["integer_field"], 5)
self.assertEqual(response.data["results"][1]["integer_field"], 4)
self.assertEqual(response.data["results"][2]["integer_field"], 3)
self.assertEqual(response.data["results"][3]["integer_field"], 2)
self.assertEqual(response.data["results"][4]["integer_field"], 1)
def test_char_field_multiple_variables(self):
ExampleModelOneFactory(char_field="Hooray", boolean_field=True)
ExampleModelOneFactory(char_field="hoor", boolean_field=True)
ExampleModelOneFactory(char_field="hank", boolean_field=True)
ExampleModelOneFactory(char_field="rank", boolean_field=True)
ExampleModelOneFactory(char_field="Stuff", boolean_field=True)
response = self.client.get(self.url +
"?char_field=hoor&char_field=ank")
self.assertEqual(response.data["total_result_count"], 4)
for result in response.data["results"]:
# Checks all results either contain hoor or ank
# Lower is used so the check is case insensitive
self.assertTrue("hoor" in result["char_field"].lower()
or "ank" in result["char_field"].lower())
def test_ordering_decimal_field(self):
ExampleModelOneFactory.create(decimal_field=Decimal("1.4"))
ExampleModelOneFactory.create(decimal_field=Decimal("1.5"))
ExampleModelOneFactory.create(decimal_field=Decimal("1.3"))
ExampleModelOneFactory.create(decimal_field=Decimal("1.1"))
ExampleModelOneFactory.create(decimal_field=Decimal("1.2"))
response = self.client.get(self.url, {"_order": "decimal_field"})
self.assertEqual(response.data["total_result_count"], 5)
self.assertEqual(response.data["results"][0]["decimal_field"], "1.10")
self.assertEqual(response.data["results"][1]["decimal_field"], "1.20")
self.assertEqual(response.data["results"][2]["decimal_field"], "1.30")
self.assertEqual(response.data["results"][3]["decimal_field"], "1.40")
self.assertEqual(response.data["results"][4]["decimal_field"], "1.50")
def test_general_query(self):
obj = ExampleModelOneFactory.create(char_field="foobar")
response = self.client.get(self.url)
self.assertEqual(response.data["results"][0]["_detail_url"],
obj.get_admin_detail_url())
def test_ordering_float_field_desc(self):
ExampleModelOneFactory.create(float_field=1.4)
ExampleModelOneFactory.create(float_field=1.5)
ExampleModelOneFactory.create(float_field=1.3)
ExampleModelOneFactory.create(float_field=1.1)
ExampleModelOneFactory.create(float_field=1.2)
response = self.client.get(self.url, {"_order": "-float_field"})
self.assertEqual(response.data["total_result_count"], 5)
self.assertEqual(response.data["results"][4]["float_field"], 1.1)
self.assertEqual(response.data["results"][3]["float_field"], 1.2)
self.assertEqual(response.data["results"][2]["float_field"], 1.3)
self.assertEqual(response.data["results"][1]["float_field"], 1.4)
self.assertEqual(response.data["results"][0]["float_field"], 1.5)
def test_general_query(self):
ExampleModelOneFactory.create(char_field="foobar")
ExampleModelOneFactory.create(text_field="dobeefoobee")
ExampleModelOneFactory.create(slug_field="lafoot")
ExampleModelOneFactory.create(text_field="")
response = self.client.get(self.url, {"_q": "foo"})
self.assertEqual(response.data["total_result_count"], 3)
def test_pagination_info_string(self):
date_time = datetime.now()
foreign_model = ExampleModelTwoFactory()
ExampleModelOneFactory.create_batch(60)
response = self.client.get(self.url, {})
self.assertEqual(
response.data["meta"]["footer_info"],
("page_result_count 50 "
"total_result_count 60 "
"current_page 1 "
"page_count 2 "
"first_result_count 1 "
"last_result_count 50 "
"per_page 50 "),
)
def test_date_field_fitlering_equal(self):
ExampleModelOneFactory(
date_field=date(year=2018, month=1, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=2, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=3, day=1), boolean_field=True
)
ExampleModelOneFactory(
date_field=date(year=2018, month=4, day=1), boolean_field=True
)
response = self.client.get(self.url + "?date_field=2018-01-01")
self.assertEqual(response.data["total_result_count"], 1)
self.assertEqual(response.data["results"][0]["date_field"], "2018-01-01")
def test_integer_filters_range(self):
valid_data = {
"integer_choice_field": 2,
"float_field": 10.0,
"decimal_field": Decimal("10"),
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
invalid_data = {
"integer_choice_field": 2,
"float_field": 10.0,
"decimal_field": Decimal("10"),
"boolean_field": True,
"nullboolean_field": False,
"char_field": "demo",
"choice_field": "foo",
"text_field": "admin",
"slug_field": "a-slug",
}
for i in range(10):
ExampleModelOneFactory(integer_field=i + 10, **valid_data)
for i in range(10):
ExampleModelOneFactory(integer_field=i, **invalid_data)
for i in range(10):
ExampleModelOneFactory(integer_field=i + 21, **invalid_data)
response = self.client.get(self.url + "?integer_field=10:20")
self.assertEqual(response.data["total_result_count"], 10)
for result in response.data["results"]:
self.assertTrue(result["integer_field"] >= 10)
self.assertTrue(result["integer_field"] <= 20)
def test_getting_data_fields_present(self):
date_time = datetime.now()
foreign_model = ExampleModelTwoFactory()
test_model_1 = ExampleModelOneFactory(
integer_field=1,
integer_choice_field=2,
float_field=10.0,
decimal_field=Decimal("10"),
boolean_field=True,
nullboolean_field=False,
char_field="demo",
choice_field="foo",
text_field="admin",
slug_field="a-slug",
date_field=date_time.date(),
other_model=foreign_model,
)
test_model_1.many_to_many_field.add(foreign_model)
response = self.client.get(self.url, {})
self.assertEqual(response.data["total_result_count"], 1)
self.assertEqual(response.data["next"], None)
self.assertEqual(response.data["previous"], None)
result = response.data["results"][0]
self.assertEqual(result["integer_field"], 1)
self.assertEqual(result["integer_choice_field"], 2)
self.assertEqual(result["float_field"], 10.0)
self.assertEqual(result["decimal_field"], "10.00")
self.assertEqual(result["boolean_field"], True)
self.assertEqual(result["nullboolean_field"], False)
self.assertEqual(result["char_field"], "demo")
self.assertEqual(result["choice_field"], "foo")
self.assertEqual(result["text_field"], "admin")
self.assertEqual(result["slug_field"], "a-slug")
self.assertEqual(result["date_field"], str(date_time.date()))
self.assertEqual(result["other_model__name"], foreign_model.name)
self.assertEqual(result["other_model__number"], foreign_model.number)
def test_ordering_slug_field(self):
ExampleModelOneFactory.create(slug_field="echo")
ExampleModelOneFactory.create(slug_field="delta")
ExampleModelOneFactory.create(slug_field="alpha")
ExampleModelOneFactory.create(slug_field="charlie")
ExampleModelOneFactory.create(slug_field="foxtrot")
ExampleModelOneFactory.create(slug_field="beta")
response = self.client.get(self.url, {"_order": "-slug_field"})
self.assertEqual(response.data["results"][5]["slug_field"], "alpha")
self.assertEqual(response.data["results"][4]["slug_field"], "beta")
self.assertEqual(response.data["results"][3]["slug_field"], "charlie")
self.assertEqual(response.data["results"][2]["slug_field"], "delta")
self.assertEqual(response.data["results"][1]["slug_field"], "echo")
self.assertEqual(response.data["results"][0]["slug_field"], "foxtrot")
