Coverage for tests\test_main.py: 100%

88 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-07-05 19:54 +0100

1import pytest 

2from sqlite_utils import Database 

3from sqlite_utils.db import Table 

4 

5from airtable_to_sqlite.constants import ( 

6 AirtablePersonalAccessToken, 

7 PreferedNamingMethod, 

8) 

9from airtable_to_sqlite.main import AirtableBaseToSqlite, get_base_records 

10from airtable_to_sqlite.schema import BaseRecord 

11 

12 

13def test_airtable_base_to_sqlite_get_schema(_mock_base_schema): 

14 db = Database(memory=True) 

15 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

16 api = AirtableBaseToSqlite( 

17 personal_access_token=AirtablePersonalAccessToken("key123"), 

18 db=db, 

19 base=base, 

20 prefer_ids=PreferedNamingMethod.ID, 

21 ) 

22 api.get_schema() 

23 assert len(api.table_meta) == 2 

24 assert api.table_meta[0].id == "tbl123" 

25 

26 

27def test_airtable_base_to_sqlite_create_metadata_tables(): 

28 db = Database(memory=True) 

29 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

30 api = AirtableBaseToSqlite( 

31 personal_access_token=AirtablePersonalAccessToken("key123"), 

32 db=db, 

33 base=base, 

34 prefer_ids=PreferedNamingMethod.ID, 

35 ) 

36 api.create_metadata_tables() 

37 assert len(api.meta_tables) == 5 

38 assert len(api.meta_tables["_meta_field_choice"].columns) == 4 

39 

40 

41def test_airtable_base_to_sqlite_create_all_table_metadata(_mock_base_schema): 

42 db = Database(memory=True) 

43 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

44 

45 api = AirtableBaseToSqlite( 

46 personal_access_token=AirtablePersonalAccessToken("key123"), 

47 db=db, 

48 base=base, 

49 prefer_ids=PreferedNamingMethod.ID, 

50 ) 

51 api.get_schema() 

52 api.create_metadata_tables() 

53 api.create_all_table_metadata() 

54 assert len(api.foreign_keys) > 0 

55 api.create_foreign_keys() 

56 

57 assert "tbl123" in db.table_names() 

58 

59 columns = [c.name for c in db["tbl123"].columns] 

60 pks = [c.name for c in db["tbl123"].columns if c.is_pk] 

61 

62 assert "_id" in columns 

63 assert "_createdTime" in columns 

64 assert pks == ["_id"] 

65 assert len(columns) == 5 

66 assert "fld123456789C" in columns 

67 

68 # test foreign keys have been created 

69 assert len(api.foreign_keys) == 0 

70 meta_table = db["_meta_table"] 

71 assert isinstance(meta_table, Table) 

72 assert len(meta_table.foreign_keys) == 1 

73 

74 

75def test_airtable_base_to_sqlite_create_all_table_metadata_prefer_name(_mock_base_schema): 

76 db = Database(memory=True) 

77 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

78 api = AirtableBaseToSqlite( 

79 personal_access_token=AirtablePersonalAccessToken("key123"), 

80 db=db, 

81 base=base, 

82 prefer_ids=PreferedNamingMethod.NAME, 

83 ) 

84 api.get_schema() 

85 api.create_metadata_tables() 

86 api.create_all_table_metadata() 

87 api.create_foreign_keys() 

88 

89 assert "My Table" in db.table_names() 

90 

91 columns = [c.name for c in db["My Table"].columns] 

92 pks = [c.name for c in db["My Table"].columns if c.is_pk] 

93 

94 assert "_id" in columns 

95 assert "_createdTime" in columns 

96 assert pks == ["_id"] 

97 assert len(columns) == 5 

98 assert "IP Address" in columns 

99 

100 

101def test_airtable_base_to_sqlite_insert_settings(_mock_base_schema): 

102 db = Database(memory=True) 

103 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

104 api = AirtableBaseToSqlite( 

105 personal_access_token=AirtablePersonalAccessToken("key123"), 

106 db=db, 

107 base=base, 

108 prefer_ids=PreferedNamingMethod.NAME, 

109 ) 

110 api.get_schema() 

111 api.create_metadata_tables() 

112 api.create_all_table_metadata() 

113 api.create_foreign_keys() 

114 api.insert_settings() 

115 

116 assert "_meta_settings" in db.table_names() 

117 

118 data = list(db["_meta_settings"].rows) 

119 

120 assert len(data) == 4 

121 

122 

123def test_airtable_base_to_sqlite_run(_mock_base_schema, _mock_api): 

124 db = Database(memory=True) 

125 base = BaseRecord(id="app123", name="My Base", permissionLevel="create") 

126 api = AirtableBaseToSqlite( 

127 personal_access_token=AirtablePersonalAccessToken("key123"), 

128 db=db, 

129 base=base, 

130 prefer_ids=PreferedNamingMethod.NAME, 

131 ) 

132 api.run() 

133 

134 assert "_meta_settings" in db.table_names() 

135 

136 data = list(db["_meta_settings"].rows) 

137 

138 assert len(data) == 4 

139 

140 

141def test_get_base_records_all(_mock_get_api_bases): 

142 bases = list(get_base_records(personal_access_token=AirtablePersonalAccessToken("key123"))) 

143 assert len(bases) == 2 

144 

145 

146def test_get_base_records_single(_mock_get_api_bases): 

147 bases = list(get_base_records(personal_access_token=AirtablePersonalAccessToken("key123"), base_ids=["app123"])) 

148 assert len(bases) == 1 

149 

150 

151def test_get_base_records_missing(_mock_get_api_bases): 

152 with pytest.raises(KeyError): 

153 list( 

154 get_base_records(personal_access_token=AirtablePersonalAccessToken("key123"), base_ids=["app123", "app456"]) 

155 ) 

156 with pytest.raises(KeyError): 

157 list(get_base_records(personal_access_token=AirtablePersonalAccessToken("key123"), base_ids=["app456"]))