예제 #1
0
def test_get_latest_accepted(db_conn, cards_table):
    """
    Expect to pull the latest accepted
    version out of the database, given a kind and an entity_id.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    e = entity.get_latest_accepted('card', 'A')

    assert isinstance(e, Card)
예제 #2
0
def create_proposal_in_db(posts_table, units_table, db_conn):
    posts_table.insert({
        'id': 'jklm',
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'topic_id': 'wxyz7890',
        'body': '''A Modest Proposal for Preventing the Children of Poor
            People From Being a Burthen to Their Parents or Country, and
            for Making Them Beneficial to the Publick.''',
        'kind': 'proposal',
        'name': 'New Unit',
        'replies_to_id': None,
        'entity_version': {
            'id': 'slash-1',
            'kind': 'unit',
        },
    }).run(db_conn)

    units_table.insert({
        'id': 'slash-1',
        'created': r.time(2014, 1, 1, 'Z'),
        'modified': r.time(2014, 1, 1, 'Z'),
        'entity_id': 'slash',
        'previous_id': None,
        'language': 'en',
        'name': 'Dividing two numbers.',
        'status': 'accepted',
        'available': True,
        'tags': ['math'],
        'body': 'The joy and pleasure of dividing numbers.',
        'require_ids': ['plus', 'minus', 'times'],
    }).run(db_conn)
예제 #3
0
def test_get_latest_accepted(db_conn, cards_table):
    """
    Expect to pull the latest accepted
    version out of the database, given a kind and an entity_id.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    e = entity.get_latest_accepted('card', 'A')

    assert isinstance(e, Card)
예제 #4
0
    def run(self, conn):
        (start_date, end_date) = self.time_dist.get()

        time_1 = r.time(start_date.year, start_date.month, start_date.day, 'Z')
        time_2 = r.time(end_date.year, end_date.month, end_date.day, 'Z')

        cursor = r.db(self.db).table(self.table).between(time_1, time_2, index="datetime").count().run(conn)

        return { }
예제 #5
0
 def get_data():
     data = [{
         'id': 'joe',
         'last_updated': r.time(2014, 6, 3, 'Z')
     }, {
         'id': 'sam',
         'last_updated': r.time(2014, 8, 25, 'Z')
     }]
     return as_db_and_table('d', 'people', data)
예제 #6
0
 def test_filter_during(self, conn):
     table = r.db('d').table('people')
     result = table.filter(
         lambda doc: doc['last_updated'].during(
             r.time(2014, 6, 1, 'Z'),
             r.time(2014, 6, 30, 'Z')
         )
     ).run(conn)
     result = list(result)
     assertEqual(2, len(result))
예제 #7
0
 def test_during_closed_right(self, conn):
     expected = [{'id': 'joe', 'is_during': True}]
     result = r.db('d').table('people').map(
         lambda doc: {
             'id':
             doc['id'],
             'is_during':
             doc['last_updated'].during(r.time(2014, 6, 2, 'Z'),
                                        r.time(2014, 8, 25, 'Z'),
                                        right_bound='closed')
         }).run(conn)
     assertEqUnordered(expected, list(result))
예제 #8
0
 def test_during_1(self, conn):
     expected = [
         {'id': 'joe', 'is_during': False},
         {'id': 'sam', 'is_during': True}
     ]
     result = r.db('d').table('people').map(
         lambda doc: {
             'id': doc['id'],
             'is_during': doc['last_updated'].during(r.time(2014, 7, 10, 'Z'), r.time(2014, 12, 1, 'Z'))
         }
     ).run(conn)
     assertEqUnordered(expected, list(result))
예제 #9
0
def update_with_date_random(db_name, tbl_name, user_object, id):
    return r.db(db_name).table(tbl_name).get(id).replace(lambda doc: r.branch(
        (doc == None),
        doc.merge(doc).merge({
            'created_at':
            r.time(random.randrange(1995, 2015, 1), random.randrange(1, 12, 1),
                   random.randrange(1, 30, 1), 'Z')
        }),
        doc.merge(doc).merge(
            {
                'created_at':
                r.time(random.randrange(1995, 2015, 1),
                       random.randrange(1, 12, 1), random.randrange(1, 30, 1),
                       'Z')
            }, {'updated_at': r.now()}))).run()
예제 #10
0
    def run(self, conn):
        cid = "customer%03d" % self.cid_dist.get()
        typ = "type%d" % self.typ_dist.get()

        (start_date, end_date) = self.time_dist.get()
        time_1 = r.time(start_date.year, start_date.month, start_date.day, 'Z')
        time_2 = r.time(end_date.year, end_date.month, end_date.day, 'Z')

        res = r.db(self.db).table(self.table).between([cid, time_1], [cid, time_2], index="compound") \
                                             .filter(lambda row: row["type"].eq(typ)) \
                                             .map(lambda row: row["arr"].reduce(lambda acc,val: acc + val, 0)) \
                                             .reduce(lambda acc,val: acc + val, 0) \
                                             .run(conn)

        return { }
예제 #11
0
    def run(self, conn):
        cid = "customer%03d" % self.cid_dist.get()
        typ = "type%d" % self.typ_dist.get()

        (start_date, end_date) = self.time_dist.get()
        time_1 = r.time(start_date.year, start_date.month, start_date.day, 'Z')
        time_2 = r.time(end_date.year, end_date.month, end_date.day, 'Z')

        res = r.db(self.db).table(self.table).between([cid, time_1], [cid, time_2], index="compound") \
                                             .filter(lambda row: row["type"].eq(typ)) \
                                             .map(lambda row: row["arr"].reduce(lambda acc,val: acc + val, 0)) \
                                             .reduce(lambda acc,val: acc + val, 0) \
                                             .run(conn)

        return {}
예제 #12
0
 def test_during_closed_right(self, conn):
     expected = [
         {'id': 'joe', 'is_during': True}
     ]
     result = r.db('d').table('people').map(
         lambda doc: {
             'id': doc['id'],
             'is_during': doc['last_updated'].during(
                 r.time(2014, 6, 2, 'Z'),
                 r.time(2014, 8, 25, 'Z'),
                 right_bound='closed'
             )
         }
     ).run(conn)
     assertEqUnordered(expected, list(result))
예제 #13
0
 def test_during_open_left(self, conn):
     expected = [
         {'id': 'joe', 'is_during': False},
         {'id': 'sam', 'is_during': False}
     ]
     result = r.db('d').table('people').map(
         lambda doc: {
             'id': doc['id'],
             'is_during': doc['last_updated'].during(
                 r.time(2014, 6, 3, 'Z'),
                 r.time(2014, 8, 25, 'Z'),
                 left_bound='open'
             )
         }
     ).run(conn)
     assertEqUnordered(expected, list(result))
예제 #14
0
 def test_error_with_less_than_4_args(self, conn):
     try:
         query = r.db('unimportant').table('very').update({
             'update_time': r.time(2014, 3, 24)
         }).run(conn)
     except RqlCompileError as e:
         err = e
     assert('expected between 4 and 7' in err.message.lower())
예제 #15
0
 def test_during_3(self, conn):
     expected = [{
         'id': 'joe',
         'is_during': True
     }, {
         'id': 'sam',
         'is_during': False
     }]
     result = r.db('d').table('people').map(
         lambda doc: {
             'id':
             doc['id'],
             'is_during':
             doc['last_updated'].during(r.time(2014, 6, 3, 'Z'),
                                        r.time(2014, 8, 25, 'Z'))
         }).run(conn)
     assertEqUnordered(expected, list(result))
예제 #16
0
def test_get_latest_accepted(db_conn, cards_table):
    """
    Expect to pull the latest accepted
    version out of the database, given a kind and an entity_id.
    """

    cards_table.insert(
        [
            {"id": "A1", "entity_id": "A", "created": r.time(2004, 11, 3, "Z"), "status": "accepted", "kind": "video"},
            {"id": "B2", "entity_id": "A", "created": r.time(2005, 11, 3, "Z"), "status": "accepted", "kind": "video"},
            {"id": "C3", "entity_id": "B", "created": r.time(2006, 11, 3, "Z"), "status": "accepted", "kind": "video"},
        ]
    ).run(db_conn)

    e = entity.get_latest_accepted(db_conn, "card", "A")

    assert isinstance(e, Card)
예제 #17
0
 def test_error_with_less_than_4_args(self, conn):
     try:
         query = r.db('unimportant').table('very').update({
             'update_time':
             r.time(2014, 3, 24)
         }).run(conn)
     except RqlCompileError as e:
         err = e
     assert ('expected between 4 and 7' in err.message.lower())
예제 #18
0
def create_proposal_in_db(posts_table, units_table, db_conn):
    posts_table.insert({
        'id':
        'jklm',
        'created':
        r.now(),
        'modified':
        r.now(),
        'user_id':
        'abcd1234',
        'topic_id':
        'wxyz7890',
        'body':
        '''A Modest Proposal for Preventing the Children of Poor
            People From Being a Burthen to Their Parents or Country, and
            for Making Them Beneficial to the Publick.''',
        'kind':
        'proposal',
        'name':
        'New Unit',
        'replies_to_id':
        None,
        'entity_versions': [{
            'id': 'slash-1',
            'kind': 'unit',
        }],
    }).run(db_conn)

    units_table.insert({
        'id': 'slash-1',
        'created': r.time(2014, 1, 1, 'Z'),
        'modified': r.time(2014, 1, 1, 'Z'),
        'entity_id': 'slash',
        'previous_id': None,
        'language': 'en',
        'name': 'Dividing two numbers.',
        'status': 'accepted',
        'available': True,
        'tags': ['math'],
        'body': 'The joy and pleasure of dividing numbers.',
        'require_ids': ['plus', 'minus', 'times'],
    }).run(db_conn)
예제 #19
0
    def test_time_year_month_day_tz(self, conn):
        r.db('unimportant').table('very').update(
            lambda doc: doc.merge({'updated': r.time(2014, 6, 10, 'Z')})
        ).run(conn)

        result = r.db('unimportant').table('very').get('say_anything').run(conn)
        update_time = result['updated']
        assertEqual(2014, update_time.year)
        assertEqual(6, update_time.month)
        assertEqual(10, update_time.day)
        assert(isinstance(update_time.tzinfo, RqlTzinfo))
예제 #20
0
    def test_time_year_month_day_tz(self, conn):
        r.db('unimportant').table('very').update(lambda doc: doc.merge(
            {'updated': r.time(2014, 6, 10, 'Z')})).run(conn)

        result = r.db('unimportant').table('very').get('say_anything').run(
            conn)
        update_time = result['updated']
        assertEqual(2014, update_time.year)
        assertEqual(6, update_time.month)
        assertEqual(10, update_time.day)
        assert (isinstance(update_time.tzinfo, RqlTzinfo))
예제 #21
0
def test_list_required_by(db_conn, cards_table):
    """
    Expect to list all the entity that require the given one.
    """

    cards_table.insert([{
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
        'requires': ['zxyz'],
    }, {
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'zxyz',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'qwer',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'choice',
        'requires': ['abcd'],
    }]).run(db_conn)

    cards = Card.list_required_by(db_conn, 'abcd')

    assert len(cards) == 1
    assert cards[0]['entity_id'] == 'qwer'
예제 #22
0
def test_list_required_by(db_conn, cards_table):
    """
    Expect to list all the entity that require the given one.
    """

    cards_table.insert([{
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
        'requires': ['zxyz'],
    }, {
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'zxyz',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'qwer',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'choice',
        'requires': ['abcd'],
    }]).run(db_conn)

    cards = Card.list_required_by(db_conn, 'abcd')

    assert len(cards) == 1
    assert cards[0]['entity_id'] == 'qwer'
예제 #23
0
def test_get_versions(db_conn, cards_table):
    """
    Expect to get the latest versions of the card.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    card_versions = Card.get_versions(db_conn, 'A')
    assert len(card_versions) == 2
예제 #24
0
def test_get_versions(db_conn, cards_table):
    """
    Expect to get the latest versions of the card.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    card_versions = Card.get_versions(db_conn, 'A')
    assert len(card_versions) == 2
예제 #25
0
    def test_time_year_month_day_hour_minute_second_tz(self, conn):
        r.db('unimportant').table('very').update({
            'updated': r.time(2014, 6, 10, 15, 30, 45, 'Z')
        }).run(conn)

        result = r.db('unimportant').table('very').get('say_anything').run(conn)
        update_time = result['updated']
        assertEqual(2014, update_time.year)
        assertEqual(6, update_time.month)
        assertEqual(10, update_time.day)
        assertEqual(15, update_time.hour)
        assertEqual(30, update_time.minute)
        assertEqual(45, update_time.second)
        assert(isinstance(update_time.tzinfo, RqlTzinfo))
예제 #26
0
def test_latest_accepted(db_conn, units_table):
    """
    Expect to get the latest accepted unit version.
    """

    units_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    unit = Unit.get_latest_accepted(db_conn, 'A')
    assert unit['id'] == 'B2'
예제 #27
0
def test_latest_accepted(db_conn, units_table):
    """
    Expect to get the latest accepted unit version.
    """

    units_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    unit = Unit.get_latest_accepted(db_conn, 'A')
    assert unit['id'] == 'B2'
예제 #28
0
def test_latest_accepted_subject(db_conn, subjects_table):
    """
    Expect to get the latest accepted subject version.
    """

    subjects_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    subject = Subject.get_latest_accepted(db_conn, 'A')
    assert subject['id'] == 'B2'
예제 #29
0
def test_latest_accepted_set(db_conn, sets_table):
    """
    Expect to get the latest accepted set version.
    """

    sets_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    set_ = Set.get_latest_accepted(db_conn, 'A')
    assert set_['id'] == 'B2'
예제 #30
0
def test_latest_accepted_card(db_conn, cards_table):
    """
    Expect to get the latest accepted card version.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    card = Card.get_latest_accepted(db_conn, 'A')
    assert card['id'] == 'B2'
예제 #31
0
def test_latest_accepted_card(db_conn, cards_table):
    """
    Expect to get the latest accepted card version.
    """

    cards_table.insert([{
        'id': 'A1',
        'entity_id': 'A',
        'created': r.time(2004, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'B2',
        'entity_id': 'A',
        'created': r.time(2005, 11, 3, 'Z'),
        'status': 'accepted',
    }, {
        'id': 'C3',
        'entity_id': 'B',
        'created': r.time(2006, 11, 3, 'Z'),
        'status': 'accepted',
    }]).run(db_conn)

    card = Card.get_latest_accepted(db_conn, 'A')
    assert card['id'] == 'B2'
예제 #32
0
    def test_time_year_month_day_hour_minute_second_tz(self, conn):
        r.db('unimportant').table('very').update({
            'updated':
            r.time(2014, 6, 10, 15, 30, 45, 'Z')
        }).run(conn)

        result = r.db('unimportant').table('very').get('say_anything').run(
            conn)
        update_time = result['updated']
        assertEqual(2014, update_time.year)
        assertEqual(6, update_time.month)
        assertEqual(10, update_time.day)
        assertEqual(15, update_time.hour)
        assertEqual(30, update_time.minute)
        assertEqual(45, update_time.second)
        assert (isinstance(update_time.tzinfo, RqlTzinfo))
예제 #33
0
파일: __init__.py 프로젝트: jean/sondra
 def to_rql_repr(self, value):
     if isinstance(value, str):
         return r.iso8601(value, default_timezone=self.DEFAULT_TIMEZONE).in_timezone(self.timezone)
     elif isinstance(value, int) or isinstance(value, float):
         return datetime.fromtimestamp(value).isoformat()
     elif isinstance(value, dict):
         return r.time(
             value.get('year', None),
             value.get('month', None),
             value.get('day', None),
             value.get('hour', None),
             value.get('minute', None),
             value.get('second', None),
             value.get('timezone', self.timezone),
         ).in_timezone(self.timezone)
     else:
         return r.iso8601(value.isoformat(), default_timezone=self.DEFAULT_TIMEZONE).as_timezone(self.timezone)
예제 #34
0
    def get_daily_activity_by_minute(self, cutoff_dt):
        assert cutoff_dt.tzinfo is not None, \
               "Cutoff timestamp must be timezone-aware."

        cutoff_dt = cutoff_dt.astimezone(pytz.UTC)

        t = self.get_table(_TABLE_DNS_MESSAGES)
        
        rows = t.filter(
                    rethinkdb.row['timestamp'].during(
                        rethinkdb.time(
                            cutoff_dt.year, 
                            cutoff_dt.month, 
                            cutoff_dt.day, 
                            cutoff_dt.hour, 
                            cutoff_dt.minute, 
                            cutoff_dt.second,
                            'Z'
                        ), 
                        rethinkdb.now()
                    )
                )\
                .filter(
                    lambda row: row['type'].match('^query')
                )\
                .group([
                    rethinkdb.row['timestamp'].year(), 
                    rethinkdb.row['timestamp'].month(), 
                    rethinkdb.row['timestamp'].day(), 
                    rethinkdb.row['timestamp'].hours(), 
                    rethinkdb.row['timestamp'].minutes(), 
                    rethinkdb.row['type']
                ])\
                .count()\
                .run(self.connection)

        for group, count in rows.items():
            (year, month, day, hour, minute, type_) = group
            yield ((year, month, day, hour, minute), type_, count)
예제 #35
0
 def get_data():
     data = [
         {'id': 'joe', 'last_updated': r.time(2014, 6, 3, 'Z')},
         {'id': 'sam', 'last_updated': r.time(2014, 8, 25, 'Z')}
     ]
     return as_db_and_table('d', 'people', data)
def insert_into_contacts(my_connections):
    i = 0
    while (i < len(my_connections) - 1):
        if (my_connections[i].get('name')):
            name = (my_connections[i].get('name'))
            name_list = name.split()
            first_name = name_list[0]
            if (len(name_list) > 2):
                last_name = name_list[1] + " " + name_list[2]
            elif (len(name_list) == 2):
                last_name = name_list[1]
            else:
                last_name = " "

        full_name = first_name + " " + last_name
        db_count = rethinkdb.table("Contacts").get_all(
            [first_name, last_name],
            index="fullname").count().run(rethinkDBConnection.connection)
        if (db_count == 0):
            count = rethinkdb.table("Contacts").count().run(
                rethinkDBConnection.connection)
            count += 1
            rethinkdb.table("Contacts").insert({
                "first_name": first_name,
                "last_name": last_name,
                'full_name': full_name,
                'serial_number': count
            }).run(rethinkDBConnection.connection)
        if (my_connections[i].get('birthdate')):
            date_of_birth = (my_connections[i].get('birthdate'))
            if date_of_birth.get('year'):
                year = date_of_birth['year']
            if date_of_birth.get('month'):
                month = date_of_birth['month']
            if date_of_birth.get('day'):
                day = date_of_birth['day']
            if (day and month and year):
                if (rethinkdb.table("Contacts").get_all(
                    [first_name, last_name], index="fullname").has_fields({
                        'Contact': {
                            'date_of_birth': True
                        }
                    }).is_empty().run(rethinkDBConnection.connection)):
                    age = rethinkdb.now().year().run(
                        rethinkDBConnection.connection) - year
                    rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").update({
                            "PersonalInfo": {
                                'date_of_birth':
                                rethinkdb.time(year, month, day, 'Z').run(
                                    rethinkDBConnection.connection),
                                'age':
                                age
                            }
                        }).run(rethinkDBConnection.connection)
                db_date = rethinkdb.table("Contacts").get_all(
                    [first_name, last_name],
                    index="fullname")['PersonalInfo'].get_field(
                        'date_of_birth')[0].run(rethinkDBConnection.connection)
                if (db_date.date().year != year
                        or db_date.date().month != month
                        or db_date.date().day != day):
                    age = rethinkdb.now().year().run(
                        rethinkDBConnection.connection) - year
                    rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").update({
                            "PersonalInfo": {
                                'date_of_birth':
                                rethinkdb.time(year, month, day, 'Z').run(
                                    rethinkDBConnection.connection),
                                'age':
                                age
                            }
                        }).run(rethinkDBConnection.connection)

        if (my_connections[i].get('numbers')):
            numbers = my_connections[i].get('numbers')
            # Add function for numbers using for
            if (len(numbers) >= 1):
                phone_number = numbers[0]
                if (phone_number):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Contact': {
                                'phone_number': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number': phone_number
                                }
                            }).run(rethinkDBConnection.connection)
                    db_phone_number = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Contact'].get_field(
                            'phone_number')[0].run(
                                rethinkDBConnection.connection)
                    if db_phone_number != phone_number:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number': phone_number
                                }
                            }).run(rethinkDBConnection.connection)
            if (len(numbers) == 2):
                phone_number1 = numbers[1]
                if (phone_number1):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Contact': {
                                'phone_number1': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number1': phone_number1
                                }
                            }).run(rethinkDBConnection.connection)
                    db_phone_number = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Contact'].get_field(
                            'phone_number1')[0].run(
                                rethinkDBConnection.connection)
                    if db_phone_number != phone_number1:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number1': phone_number1
                                }
                            }).run(rethinkDBConnection.connection)
            if (len(numbers) > 2):
                phone_number2 = numbers[2]
                if (phone_number2):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Contact': {
                                'phone_number2': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number2': phone_number2
                                }
                            }).run(rethinkDBConnection.connection)
                    db_phone_number = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Contact'].get_field(
                            'phone_number2')[0].run(
                                rethinkDBConnection.connection)
                    if db_phone_number != phone_number2:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Contact": {
                                    'phone_number2': phone_number2
                                }
                            }).run(rethinkDBConnection.connection)
        if (my_connections[i].get('emails')):
            emails = my_connections[i].get('emails')

            if (len(emails) >= 1):
                email_id = emails[0]
                if (email_id):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Email': {
                                'email_id': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id': email_id
                                }
                            }).run(rethinkDBConnection.connection)
                    db_email_id = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Email'].get_field(
                            'email_id')[0].run(rethinkDBConnection.connection)
                    if db_email_id != email_id:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id': email_id
                                }
                            }).run(rethinkDBConnection.connection)
            if (len(emails) == 2):
                email_id1 = emails[1]
                if (email_id1):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Email': {
                                'email_id1': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id1': email_id1
                                }
                            }).run(rethinkDBConnection.connection)
                    db_email_id = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Email'].get_field(
                            'email_id1')[0].run(rethinkDBConnection.connection)
                    if db_email_id != email_id1:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id1': email_id1
                                }
                            }).run(rethinkDBConnection.connection)

            if (len(emails) > 2):
                email_id2 = emails[2]
                if (email_id2):
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Email': {
                                'email_id2': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id2': email_id2
                                }
                            }).run(rethinkDBConnection.connection)
                    db_email_id = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Email'].get_field(
                            'email_id2')[0].run(rethinkDBConnection.connection)
                    if db_email_id != email_id2:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Email": {
                                    'email_id2': email_id2
                                }
                            }).run(rethinkDBConnection.connection)

        if (my_connections[i].get('address')):
            address = my_connections[i].get('address')
            if address['formattedValue'] is not None:
                str_address = address['formattedValue']
                if str_address:
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Address': {
                                'address': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'address': str_address
                                }
                            }).run(rethinkDBConnection.connection)
                    db_address = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Address'].get_field(
                            'address')[0].run(rethinkDBConnection.connection)
                    if db_address != str_address:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'address': str_address
                                }
                            }).run(rethinkDBConnection.connection)
            if address['city'] is not None:
                city = address['city']
                if city:
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Address': {
                                'address': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'city': city
                                }
                            }).run(rethinkDBConnection.connection)
                    db_address = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Address'].get_field('city').run(
                            rethinkDBConnection.connection)
                    if db_address != city:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'city': city
                                }
                            }).run(rethinkDBConnection.connection)
            if address['country'] is not None:
                country = address['country']
                if country:
                    if (rethinkdb.table("Contacts").get_all(
                        [first_name, last_name], index="fullname").has_fields({
                            'Address': {
                                'country': True
                            }
                        }).is_empty().run(rethinkDBConnection.connection)):
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'country': country
                                }
                            }).run(rethinkDBConnection.connection)
                    db_address = rethinkdb.table("Contacts").get_all(
                        [first_name, last_name],
                        index="fullname")['Address'].get_field(
                            'country')[0].run(rethinkDBConnection.connection)
                    if db_address != country:
                        rethinkdb.table("Contacts").get_all(
                            [first_name, last_name], index="fullname").update({
                                "Address": {
                                    'country': country
                                }
                            }).run(rethinkDBConnection.connection)

        i += 1
예제 #37
0
 def test_filter_during(self, conn):
     table = r.db('d').table('people')
     result = table.filter(lambda doc: doc['last_updated'].during(
         r.time(2014, 6, 1, 'Z'), r.time(2014, 6, 30, 'Z'))).run(conn)
     result = list(result)
     assertEqual(2, len(result))
def add_test_set(db_conn,
                 users_table=None, units_table=None, responses_table=None,
                 sets_table=None):
    """
    Add doesn't require anything.
    Multiply requires add.
    Subtract requires add.
    Divide requires multiply.

    Add is done,
    Subtract needs review,
    Multiply needs to be learned,
    Divide needs to be diagnosed.
    """

    if users_table:
        users_table.insert({
            'id': 'user'
        }).run(db_conn)

    if units_table:
        units_table.insert([{
            'entity_id': 'add',
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'subtract',
            'require_ids': ['add'],
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'multiply',
            'require_ids': ['add'],
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'divide',
            'require_ids': ['multiply', 'subtract'],
            'status': 'accepted',
            'created': r.now()
        }]).run(db_conn)

    if responses_table:
        responses_table.insert([{
            'user_id': 'user', 'unit_id': 'add', 'learned': 0.99,
            'created': r.now()
        }, {
            'user_id': 'user', 'unit_id': 'multiply', 'learned': 0.0,
            'created': r.now()
        }, {
            'user_id': 'user', 'unit_id': 'subtract', 'learned': 0.99,
            'created': r.time(2004, 11, 3, 'Z')
        }]).run(db_conn)

    if sets_table:
        sets_table.insert({
            'entity_id': 'set',
            'status': 'accepted',
            'members': [
                {'id': 'add', 'kind': 'unit'},
                {'id': 'subtract', 'kind': 'unit'},
                {'id': 'multiply', 'kind': 'unit'},
                {'id': 'divide', 'kind': 'unit'},
            ]
        }).run(db_conn)
예제 #39
0
    'posts',
    'follows',
    'notices',
    'users_sets',
    'responses',
):
    (r.table(kind)
      .delete()
      .run(db_conn))

es.indices.delete(index='entity', ignore=[400, 404])

(r.table('users')
    .insert([{
        'id': 'doris',
        'created': r.time(2014, 1, 1, 'Z'),
        'modified': r.time(2014, 1, 1, 'Z'),
        'name': 'doris',
        'email': '*****@*****.**',
        'password': bcrypt.encrypt('example1'),
        'settings': {
            'email_frequency': 'daily',
            'view_sets': 'public',
            'view_follows': 'public',
        }
    }, {
        'id': 'eileen',
        'created': r.time(2014, 1, 1, 'Z'),
        'modified': r.time(2014, 1, 1, 'Z'),
        'name': 'eileen',
        'email': '*****@*****.**',
예제 #40
0
def test_get_card(db_conn, cards_table, cards_parameters_table, units_table,
                  topics_table):
    """
    Expect to get the card information for displaying to a contributor.
    """

    cards_table.insert([{
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
        'requires': ['zxyz'],
    }, {
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'zxyz',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'qwer',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'choice',
        'requires': ['abcd'],
    }]).run(db_conn)

    cards_parameters_table.insert({
        'entity_id': 'abcd',
    }).run(db_conn)

    units_table.insert({
        'entity_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
    }).run(db_conn)

    topics_table.insert([{
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Modest Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'Another Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }]).run(db_conn)

    code, response = routes.card.get_card_route({}, 'abcd')
    assert code == 200
    # Model
    assert response['card']['entity_id'] == 'abcd'
    assert response['card']['kind'] == 'video'
    # Unit
    assert response['unit']['name'] == 'Wildwood'
    # Versions
    assert len(response['versions']) == 2
    assert response['versions'][0]['kind'] == 'video'
    # Topics
    assert len(response['topics']) == 2
    assert response['topics'][0]['entity']['id'] == 'abcd'
    # Requires
    assert len(response['requires']) == 1
    assert response['requires'][0]['entity_id'] == 'zxyz'
    # Required By
    assert len(response['required_by']) == 1
    assert response['required_by'][0]['entity_id'] == 'qwer'
예제 #41
0
def update_with_date_random(db_name,tbl_name, user_object,id):
    return r.db(db_name).table(tbl_name).get(id).replace(
        lambda doc: r.branch(
            (doc == None),
            doc.merge(doc).merge({'created_at': r.time(random.randrange(1995,2015,1), random.randrange(1,12,1), random.randrange(1,30,1), 'Z')}),
            doc.merge(doc).merge({'created_at': r.time(random.randrange(1995,2015,1), random.randrange(1,12,1), random.randrange(1,30,1), 'Z')},{'updated_at': r.now()}))).run()
예제 #42
0
def test_get_set(db_conn, sets_table, units_table, topics_table):
    """
    Expect to get the set information for displaying to a contributor.
    """

    sets_table.insert([{
        'entity_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
        'members': [{
            'kind': 'unit',
            'id': 'W'
        }]
    }, {
        'entity_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'name': 'Umberwood',
    }]).run(db_conn)

    units_table.insert({
        'entity_id': 'W',
        'name': 'Wood',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
    }).run(db_conn)

    topics_table.insert([{
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Modest Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'set'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'Another Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'set'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Third Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }]).run(db_conn)

    code, response = routes.set.get_set_route({}, 'zytx')
    assert code == 200
    # Model
    assert response['set']['entity_id'] == 'zytx'
    assert response['set']['name'] == 'Wildwood'
    # Topics
    assert len(response['topics']) == 2
    assert response['topics'][0]['entity']['kind'] == 'set'
    # Versions
    assert len(response['versions']) == 2
    assert response['versions'][1]['name'] == 'Umberwood'
    # Units
    assert len(response['units']) == 1
    assert response['units'][0]['entity_id'] == 'W'
def add_test_set(db_conn,
                 users_table=None,
                 units_table=None,
                 responses_table=None,
                 sets_table=None):
    """
    Add doesn't require anything.
    Multiply requires add.
    Subtract requires add.
    Divide requires multiply.

    Add is done,
    Subtract needs review,
    Multiply needs to be learned,
    Divide needs to be diagnosed.
    """

    if users_table:
        users_table.insert({'id': 'user'}).run(db_conn)

    if units_table:
        units_table.insert([{
            'entity_id': 'add',
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'subtract',
            'require_ids': ['add'],
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'multiply',
            'require_ids': ['add'],
            'status': 'accepted',
            'created': r.now()
        }, {
            'entity_id': 'divide',
            'require_ids': ['multiply', 'subtract'],
            'status': 'accepted',
            'created': r.now()
        }]).run(db_conn)

    if responses_table:
        responses_table.insert([{
            'user_id': 'user',
            'unit_id': 'add',
            'learned': 0.99,
            'created': r.now()
        }, {
            'user_id': 'user',
            'unit_id': 'multiply',
            'learned': 0.0,
            'created': r.now()
        }, {
            'user_id': 'user',
            'unit_id': 'subtract',
            'learned': 0.99,
            'created': r.time(2004, 11, 3, 'Z')
        }]).run(db_conn)

    if sets_table:
        sets_table.insert({
            'entity_id':
            'set',
            'status':
            'accepted',
            'members': [
                {
                    'id': 'add',
                    'kind': 'unit'
                },
                {
                    'id': 'subtract',
                    'kind': 'unit'
                },
                {
                    'id': 'multiply',
                    'kind': 'unit'
                },
                {
                    'id': 'divide',
                    'kind': 'unit'
                },
            ]
        }).run(db_conn)
예제 #44
0
def test_get_unit(db_conn,
                  units_table, sets_table, topics_table):
    """
    Expect to get the unit information for displaying to a contributor.
    """

    units_table.insert([{
        'entity_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
        'requires': ['ntza'],
    }, {
        'entity_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'name': 'Umberwood',
    }, {
        'entity_id': 'ntza',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'name': 'Limberwood',
    }, {
        'entity_id': 'tyui',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
        'requires': ['zytx'],
    }]).run(db_conn)

    sets_table.insert({
        'entity_id': 'W',
        'name': 'Woods',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'members': [{
            'kind': 'unit',
            'id': 'zytx',
        }]
    }).run(db_conn)

    topics_table.insert([{
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Modest Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'unit'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'Another Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'unit'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Third Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }]).run(db_conn)

    code, response = routes.unit.get_unit_route({
        'db_conn': db_conn
    }, 'zytx')
    assert code == 200
    # Model
    assert response['unit']['entity_id'] == 'zytx'
    assert response['unit']['name'] == 'Wildwood'
    # Topics
    assert len(response['topics']) == 2
    assert response['topics'][0]['entity']['kind'] == 'unit'
    # Versions
    assert len(response['versions']) == 2
    assert response['versions'][1]['name'] == 'Umberwood'
    # Requires
    assert len(response['requires']) == 1
    assert response['requires'][0]['entity_id'] == 'ntza'
    # Required By
    assert len(response['required_by']) == 1
    assert response['required_by'][0]['entity_id'] == 'tyui'
    # Sets
    assert len(response['belongs_to']) == 1
    assert response['belongs_to'][0]['entity_id'] == 'W'
예제 #45
0
def test_get_set(db_conn,
                 sets_table, units_table, topics_table):
    """
    Expect to get the set information for displaying to a contributor.
    """

    sets_table.insert([{
        'entity_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
        'members': [{
            'kind': 'unit',
            'id': 'W'
        }]
    }, {
        'entity_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'name': 'Umberwood',
    }]).run(db_conn)

    units_table.insert({
        'entity_id': 'W',
        'name': 'Wood',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
    }).run(db_conn)

    topics_table.insert([{
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Modest Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'set'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'Another Proposal',
        'entity': {
            'id': 'zytx',
            'kind': 'set'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Third Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }]).run(db_conn)

    code, response = routes.set.get_set_route({
        'db_conn': db_conn
    }, 'zytx')
    assert code == 200
    # Model
    assert response['set']['entity_id'] == 'zytx'
    assert response['set']['name'] == 'Wildwood'
    # Topics
    assert len(response['topics']) == 2
    assert response['topics'][0]['entity']['kind'] == 'set'
    # Versions
    assert len(response['versions']) == 2
    assert response['versions'][1]['name'] == 'Umberwood'
    # Units
    assert len(response['units']) == 1
    assert response['units'][0]['entity_id'] == 'W'
예제 #46
0
def test_get_card(db_conn, cards_table, cards_parameters_table, units_table,
                  topics_table):
    """
    Expect to get the card information for displaying to a contributor.
    """

    cards_table.insert([{
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
        'requires': ['zxyz'],
    }, {
        'entity_id': 'abcd',
        'unit_id': 'zytx',
        'created': r.time(1986, 11, 3, 'Z'),
        'modified': r.time(1986, 11, 3, 'Z'),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'zxyz',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'video',
    }, {
        'entity_id': 'qwer',
        'unit_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'kind': 'choice',
        'requires': ['abcd'],
    }]).run(db_conn)

    cards_parameters_table.insert({
        'entity_id': 'abcd',
    }).run(db_conn)

    units_table.insert({
        'entity_id': 'zytx',
        'created': r.now(),
        'modified': r.now(),
        'status': 'accepted',
        'name': 'Wildwood',
    }).run(db_conn)

    topics_table.insert([{
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'A Modest Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }, {
        'created': r.now(),
        'modified': r.now(),
        'user_id': 'abcd1234',
        'name': 'Another Proposal',
        'entity': {
            'id': 'abcd',
            'kind': 'card'
        }
    }]).run(db_conn)

    code, response = routes.card.get_card_route({
        'db_conn': db_conn
    }, 'abcd')
    assert code == 200
    # Model
    assert response['card']['entity_id'] == 'abcd'
    assert response['card']['kind'] == 'video'
    # Unit
    assert response['unit']['name'] == 'Wildwood'
    # Versions
    assert len(response['versions']) == 2
    assert response['versions'][0]['kind'] == 'video'
    # Topics
    assert len(response['topics']) == 2
    assert response['topics'][0]['entity']['id'] == 'abcd'
    # Requires
    assert len(response['requires']) == 1
    assert response['requires'][0]['entity_id'] == 'zxyz'
    # Required By
    assert len(response['required_by']) == 1
    assert response['required_by'][0]['entity_id'] == 'qwer'
예제 #47
0
        'sets',
        'sets_parameters',
        'topics',
        'posts',
        'follows',
        'notices',
        'users_sets',
        'responses',
):
    (database.db.table(kind).delete().run(database.db_conn))

es.indices.delete(index='entity', ignore=[400, 404])

(database.db.table('users').insert([{
    'id': 'doris',
    'created': r.time(2014, 1, 1, 'Z'),
    'modified': r.time(2014, 1, 1, 'Z'),
    'name': 'doris',
    'email': '*****@*****.**',
    'password': bcrypt.encrypt('example1'),
    'settings': {
        'email_frequency': 'daily',
        'view_sets': 'public',
        'view_follows': 'public',
    }
}, {
    'id': 'eileen',
    'created': r.time(2014, 1, 1, 'Z'),
    'modified': r.time(2014, 1, 1, 'Z'),
    'name': 'eileen',
    'email': '*****@*****.**',
def add_test_set(db_conn, users_table=None, units_table=None, responses_table=None, sets_table=None):
    """
    Add doesn't require anything.
    Multiply requires add.
    Subtract requires add.
    Divide requires multiply.

    Add is done,
    Subtract needs review,
    Multiply needs to be learned,
    Divide needs to be diagnosed.
    """

    if users_table:
        users_table.insert({"id": "user"}).run(db_conn)

    if units_table:
        units_table.insert(
            [
                {"entity_id": "add", "status": "accepted", "created": r.now()},
                {"entity_id": "subtract", "require_ids": ["add"], "status": "accepted", "created": r.now()},
                {"entity_id": "multiply", "require_ids": ["add"], "status": "accepted", "created": r.now()},
                {
                    "entity_id": "divide",
                    "require_ids": ["multiply", "subtract"],
                    "status": "accepted",
                    "created": r.now(),
                },
            ]
        ).run(db_conn)

    if responses_table:
        responses_table.insert(
            [
                {"user_id": "user", "unit_id": "add", "learned": 0.99, "created": r.now()},
                {"user_id": "user", "unit_id": "multiply", "learned": 0.0, "created": r.now()},
                {"user_id": "user", "unit_id": "subtract", "learned": 0.99, "created": r.time(2004, 11, 3, "Z")},
            ]
        ).run(db_conn)

    if sets_table:
        sets_table.insert(
            {
                "entity_id": "set",
                "status": "accepted",
                "members": [
                    {"id": "add", "kind": "unit"},
                    {"id": "subtract", "kind": "unit"},
                    {"id": "multiply", "kind": "unit"},
                    {"id": "divide", "kind": "unit"},
                ],
            }
        ).run(db_conn)