Python queries.Session类代码示例

 def test_expired_charges (self):
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("2")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 10, start, start)
     allocation_2 = Allocation(project_1, resource_1, 20, start, end)
     allocation_3 = Allocation(project_2, resource_1, 30, start, end)
     allocation_4 = Allocation(project_2, resource_2, 35, start, start)
     Charge(allocation_1, 10)
     Charge(allocation_2, 15)
     Charge(allocation_2, 5)
     Charge(allocation_4, 9)
     Charge(allocation_4, 8)
     allocations = [allocation_1, allocation_2, allocation_3, allocation_4]
     Session.add_all(allocations)
     Session.flush()
     assert_equal(
         list(allocation_summary(allocations)),
         [(allocation_1, 0, 10, 0),
          (allocation_2, 0, 20, 0),
          (allocation_3, 0, 0, 30),
          (allocation_4, 0, 17, 0)])

 def test_jobs (self):
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("1")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 0, start, end)
     allocation_2 = Allocation(project_2, resource_2, 0, start, end)
     job_1 = Job("1.1")
     job_2 = Job("1.2")
     job_3 = Job("1.3")
     job_4 = Job("2.1")
     job_5 = Job("2.2")
     charge_1 = Charge(allocation_1, 0)
     charge_2 = Charge(allocation_1, 0)
     charge_3 = Charge(allocation_1, 0)
     charge_4 = Charge(allocation_2, 0)
     charge_5 = Charge(allocation_2, 0)
     charge_1.job = job_1
     charge_2.job = job_2
     charge_3.job = job_3
     charge_4.job = job_4
     charge_5.job = job_5
     job_1.account = project_1
     job_2.account = project_1
     job_3.account = project_1
     job_4.account = project_2
     job_5.account = project_2
     Session.add_all([job_1, job_2, job_3, job_4, job_5])
     assert_equal(list(project_summary([project_1, project_2])),
                  [("1", 3, 0, 0), ("2", 2, 0, 0)])

 def test_holds (self):
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("2")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 10, start, end)
     allocation_2 = Allocation(project_1, resource_1, 20, start, end)
     allocation_3 = Allocation(project_2, resource_1, 30, start, end)
     allocation_4 = Allocation(project_2, resource_2, 35, start, end)
     Hold(allocation_1, 10)
     h2 = Hold(allocation_2, 15)
     Hold(allocation_2, 5)
     Hold(allocation_4, 9)
     h5 = Hold(allocation_4, 8)
     h2.active = False
     h5.active = False
     allocations = [allocation_1, allocation_2, allocation_3, allocation_4]
     Session.add_all(allocations)
     Session.flush()
     assert_equal(
         list(allocation_summary(allocations)),
         [(allocation_1, 0, 0, 0),
          (allocation_2, 0, 0, 15),
          (allocation_3, 0, 0, 30),
          (allocation_4, 0, 0, 26)])

 def test_refunds (self):
     user_1 = User.cached("1")
     user_2 = User.cached("2")
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 0, start, end)
     allocation_2 = Allocation(project_2, resource_1, 0, start, end)
     job_1 = Job("1")
     job_2 = Job("2")
     job_3 = Job("3")
     job_4 = Job("4")
     job_1.user_id = "1"
     job_2.user_id = "2"
     job_3.user_id = "2"
     job_4.user_id = "2"
     job_1.charges = [Charge(allocation_1, 1)]
     job_2.charges = [Charge(allocation_1, 2)]
     job_3.charges = [Charge(allocation_2, 4)]
     job_4.charges = [Charge(allocation_2, 8)]
     Refund(job_1.charges[0], 1)
     Refund(job_2.charges[0], 2)
     Refund(job_3.charges[0], 3)
     Refund(job_4.charges[0], 4)
     Session.add_all([allocation_1, allocation_2])
     assert_equal(
         list(user_summary([user_1, user_2])),
         [("1", 1, 0), ("2", 3, 5)])

 def test_refund_amount_negative (self):
     a = Allocation(Project("1"), Resource("1"), 10,
                    datetime.now(), datetime.now())
     c = Charge(a, 5)
     r = Refund(c, -1)
     Session.add(r)
     Session.commit()

 def test_with_jobs (self):
     job_1 = Job("1")
     job_1.user_id = "1"
     job_2 = Job("2")
     job_2.user_id = "2"
     dt = datetime(2000, 1, 1)
     Session.add_all([job_1, job_2])
     assert_equal(
         set(get_users()),
         set([User.cached("1"), User.cached("2")]))

 def test_member_projects (self):
     job_1 = Job("1")
     job_1.user_id = "1"
     job_2 = Job("2")
     job_2.user_id = "2"
     dt = datetime(2000, 1, 1)
     Session.add_all([job_1, job_2])
     assert_equal(
         get_users(member=Project.cached("1")),
         [User.cached("1")])

 def test_before_filter (self):
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("2")
     user_1 = User.cached("1")
     user_2 = User.cached("2")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 10, start, end)
     allocation_2 = Allocation(project_1, resource_1, 20, start, end)
     allocation_3 = Allocation(project_2, resource_1, 30, start, end)
     allocation_4 = Allocation(project_2, resource_2, 35, start, end)
     charge_1 = Charge(allocation_1, 10)
     charge_2 = Charge(allocation_2, 15)
     charge_3 = Charge(allocation_2, 5)
     charge_4 = Charge(allocation_4, 9)
     charge_5 = Charge(allocation_4, 8)
     Refund(charge_1, 4)
     Refund(charge_2, 3)
     Refund(charge_2, 5)
     Refund(charge_5, 8)
     Hold(allocation_4, 9)
     hold_2 = Hold(allocation_4, 8)
     hold_2.active = False
     charge_1.job = Job("1.1")
     charge_2.job = Job("1.2")
     charge_3.job = Job("1.3")
     charge_4.job = Job("2.1")
     charge_5.job = Job("2.2")
     charge_1.job.user = user_1
     charge_2.job.user = user_2
     charge_3.job.user = user_1
     charge_4.job.user = user_1
     charge_5.job.user = user_2
     charge_1.datetime = datetime(2000, 1, 2)
     charge_2.datetime = datetime(2000, 1, 3)
     charge_3.datetime = datetime(2000, 1, 4)
     charge_4.datetime = datetime(2000, 1, 5)
     charge_5.datetime = datetime(2000, 1, 6)
     charge_1.job.start = datetime(2000, 1, 1)
     charge_2.job.start = datetime(2000, 1, 2)
     charge_3.job.start = datetime(2000, 1, 3)
     charge_4.job.start = datetime(2000, 1, 4)
     charge_5.job.start = datetime(2000, 1, 5)
     allocations = [allocation_1, allocation_2, allocation_3, allocation_4]
     Session.add_all(allocations)
     Session.flush()
     assert_equal(
         list(allocation_summary(allocations, before=datetime(2000, 1, 4))),
         [(allocation_1, 1, 6, 4),
          (allocation_2, 2, 7, 8),
          (allocation_3, 0, 0, 30),
          (allocation_4, 0, 0, 17)])

 def test_negative_balance (self):
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation = Allocation(
         Project.cached("1"),
         Resource.cached("1"),
         10, start, end)
     Charge(allocation, 20)
     Session.add_all([allocation])
     Session.flush()
     assert_equal(list(allocation_summary([allocation])),
                  [(allocation, 0, 20, 0)])

 def test_holds_specific_resource (self):
     project_1 = Project.cached("1")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("2")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 10, start, end)
     allocation_2 = Allocation(project_1, resource_2, 20, start, end)
     Hold(allocation_1, 10)
     Hold(allocation_2, 15)
     Session.add_all([allocation_1, allocation_2])
     assert_equal(list(project_summary([project_1], resources=[resource_2])),
                  [("1", 0, 0, 5)])

 def test_allocations (self):
     project_1 = Mock(['id'])
     project_1.id = "1"
     project_2 = Mock(['id'])
     project_2.id = "2"
     resource = Mock(['id'])
     resource.id = "1"
     dt = datetime(2000, 1, 1)
     Session.add(Allocation(project_1, resource, 0, dt, dt))
     Session.add(Allocation(project_2, resource, 0, dt, dt))
     assert_equal(
         set(get_projects()),
         set([Project.cached("1"), Project.cached("2")]))

 def test_manager_projects (self):
     project_1 = Mock(['id'])
     project_1.id = "1"
     project_2 = Mock(['id'])
     project_2.id = "2"
     resource = Mock(['id'])
     resource.id = "1"
     dt = datetime(2000, 1, 1)
     Session.add(Allocation(project_1, resource, 0, dt, dt))
     Session.add(Allocation(project_2, resource, 0, dt, dt))
     assert_equal(
         get_projects(manager=User.cached("1")),
         [Project.cached("1")])

 def test_expired_allocations (self):
     project_1 = Project.cached("1")
     project_2 = Project.cached("2")
     resource_1 = Resource.cached("1")
     resource_2 = Resource.cached("2")
     start = datetime(2000, 1, 1)
     end = start + timedelta(weeks=1)
     allocation_1 = Allocation(project_1, resource_1, 10, start, start)
     allocation_2 = Allocation(project_1, resource_1, 20, start, start)
     allocation_3 = Allocation(project_2, resource_1, 30, start, end)
     allocation_4 = Allocation(project_2, resource_2, 35, start, start)
     Session.add_all([
         allocation_1, allocation_2, allocation_3, allocation_4])
     assert_equal(list(project_summary([project_1, project_2])),
                  [("1", 0, 0, 0), ("2", 0, 0, 30)])

 def test_charge_sum_zero (self):
     allocation = Allocation(None, None, 0, datetime(2000, 1, 1), datetime(2001, 1, 1))
     allocation.project_id = "project"
     allocation.resource_id = "resource"
     Session.add(allocation)
     Session.commit()
     Session.close()
     allocation = Session.query(Allocation).one()
     assert_equal(allocation._charge_sum, 0)

 def test_charge_sum_one (self):
     allocation = Allocation(None, None, 0, datetime(2000, 1, 1), datetime(2001, 1, 1))
     allocation.project_id = "project"
     allocation.resource_id = "resource"
     charge = Charge(allocation, 1)
     Session.add_all([allocation, charge])
     Session.commit()
     Session.close()
     allocation = Session.query(Allocation).one()
     assert_equal(allocation._charge_sum, 1)