def test_query_logs_final_sql(self):
     q = SimpleQueryFactory(sql="select '$$foo$$';")
     q.params = {'foo': 'bar'}
     q.log(None)
     self.assertEqual(1, QueryLog.objects.count())
     log = QueryLog.objects.first()
     self.assertEqual(log.sql, "select 'bar';")

 def test_get_run_count(self):
     q = SimpleQueryFactory()
     self.assertEqual(q.get_run_count(), 0)
     expected = 4
     for i in range(0, expected):
         q.log()
     self.assertEqual(q.get_run_count(), expected)

    def test_simple_query_runs(self):

        expected_csv = 'two\r\n2\r\n'

        r = SimpleQueryFactory()
        result = r.csv_report()

        self.assertIsNotNone(result, "Query '%s' returned None." % r.title)
        self.assertEqual(result.lower(), expected_csv)

 def test_query_log(self):
     self.assertEqual(0, QueryLog.objects.count())
     q = SimpleQueryFactory()
     q.log(None)
     self.assertEqual(1, QueryLog.objects.count())
     log = QueryLog.objects.first()
     self.assertEqual(log.run_by_user, None)
     self.assertEqual(log.query, q)
     self.assertFalse(log.is_playground)

 def test_avg_duration(self):
     q = SimpleQueryFactory()
     self.assertIsNone(q.avg_duration())
     expected = 2.5
     ql = q.log()
     ql.duration = 2
     ql.save()
     ql = q.log()
     ql.duration = 3
     ql.save()
     self.assertEqual(q.avg_duration(), expected)

 def setUp(self):
     self.user = User.objects.create_superuser("admin", "[email protected]", "pwd")
     self.user2 = User.objects.create_superuser("admin2", "[email protected]", "pwd")
     self.client.login(username="admin", password="pwd")
     self.query = SimpleQueryFactory.build()
     self.data = model_to_dict(self.query)
     self.data["created_by_user"] = 2

 def test_run_count(self):
     q = SimpleQueryFactory(title='foo - bar1')
     for i in range(0, 4):
         q.log()
     resp = self.client.get(reverse("explorer_index"))
     self.assertContains(resp, '<td>4</td>')

 def test_blacklist_check_runs_before_execution(self):
     q = SimpleQueryFactory(sql='select 1;')
     with AssertMethodIsCalled(q, "passes_blacklist"):
         headers, data, duration, error = q.headers_and_data()

 def test_blacklist_prevents_bad_sql_from_executing(self):
     q = SimpleQueryFactory(sql='select 1 "delete";')
     headers, data, duration, error = q.headers_and_data()
     self.assertEqual(error, MSG_FAILED_BLACKLIST)

 def test_params_get_merged(self):
     q = SimpleQueryFactory(sql="select '$$foo$$';")
     q.params = {'foo': 'bar', 'mux': 'qux'}
     self.assertEqual(q.available_params(), {'foo': 'bar'})

 def test_form_fails_blacklist_even_with_params(self):
     q = SimpleQueryFactory(sql="delete $$a$$;", created_by_user_id=None)
     q.params = {}
     form = QueryForm(model_to_dict(q))
     self.assertFalse(form.is_valid())

 def test_form_is_always_valid_with_params(self):
     q = SimpleQueryFactory(sql="select $$a$$;")
     q.params = {}
     form = QueryForm(model_to_dict(q))
     self.assertTrue(form.is_valid())

 def test_blacklist_prevents_bad_sql_with_params_from_executing(self):
     q = SimpleQueryFactory(sql="select '$$foo$$';")
     q.params = {"foo": "'; delete from *; select'"}
     res = q.headers_and_data()
     self.assertEqual(res.error, MSG_FAILED_BLACKLIST)

 def test_final_sql_uses_merged_params(self):
     q = SimpleQueryFactory(sql="select '$$foo:bar$$', '$$qux$$';")
     q.params = {'qux': 'mux'}
     expected = "select 'bar', 'mux';"
     self.assertEqual(q.final_sql(), expected)

 def test_log_saves_duration(self):
     q = SimpleQueryFactory()
     res, ql = q.execute_with_logging(None)
     log = QueryLog.objects.first()
     self.assertEqual(log.duration, res.duration)

 def test_default_params_used(self):
     q = SimpleQueryFactory(sql="select '$$foo:bar$$';")
     self.assertEqual(q.available_params(), {'foo': 'bar'})