2119

pending completion

Build # 2119

Build Type

Pull #649

travis-ci-com

Committed by

web-flow

Commit Message

Merge e21e75d90 into 46e1fdac5

Pull Request Pull Request #649: Log conversation data

Run Details

9931 of 20047 branches covered (49.54%)

Branch coverage included in aggregate %.

29 of 32 new or added lines in 2 files covered. (90.63%)

15 existing lines in 4 files now uncovered.

23527 of 39539 relevant lines covered (59.5%)

492777.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.78

/lib/engine/db/index.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2021 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

import * as Tp from 'thingpedia';

import { SQLiteDatabase, SQLitePlatform } from './sqlite';
import { DatabaseProxy, DatabaseProxyConfig }  from './dbproxy';

export interface AbstractRow {
    uniqueId : string;
}

export interface AppRow {
    uniqueId : string;
    code : string;
    state : string;
    name : string;
    description : string;
}

export interface ChannelRow {
    uniqueId : string;
    value : string;
}

export interface DeviceRow {
    uniqueId : string;
    state : string;
}

export interface ConversationRow {
    uniqueId : string;
    conversationId : string;
    previousId : string|null;
    dialogueId : string;
    context : string|null;
    agent : string|null;
    agentTimestamp : string|null;
    agentTarget : string|null;
    intermediateContext : string|null;
    user : string;
    userTimestamp : string|null;
    userTarget : string;
}

export interface LocalTables {
    app : AppRow;
    channel : ChannelRow;
    conversation : ConversationRow;
}

export interface SyncTables {
    device : DeviceRow;
}

export interface LocalTable<RowType extends AbstractRow> {
    name : string;

    getAll() : Promise<RowType[]>;
    getOne(uniqueId : string) : Promise<RowType|undefined>;
    insertOne(uniqueId : string, row : Omit<RowType, "uniqueId">) : Promise<void>;
    deleteOne(uniqueId : string) : Promise<void>;
}

export type SyncRecord<RowType> = { [K in keyof RowType] : RowType[K]|null } & { uniqueId : string; lastModified : number };
export interface SyncAtReply<RowType> {
    lastModified : number;
    ourChanges : Array<SyncRecord<RowType>>;
    done : boolean[];
}

export interface SyncTable<RowType extends AbstractRow>{
    name : string;
    fields : ReadonlyArray<keyof RowType>;

    getAll() : Promise<RowType[]>;
    getOne(uniqueId : string) : Promise<RowType|undefined>;
    insertOne(uniqueId : string, row : Omit<RowType, "uniqueId">) : Promise<number>;
    deleteOne(uniqueId : string) : Promise<number>;

    getRaw() : Promise<Array<SyncRecord<RowType>>>;
    getChangesAfter(lastModified : number) : Promise<Array<SyncRecord<RowType>>>;
    handleChanges(changes : Array<SyncRecord<RowType>>) : Promise<boolean[]>;
    syncAt(lastModified : number, pushedChanges : Array<SyncRecord<RowType>>) : Promise<SyncAtReply<RowType>>;
    replaceAll(data : Array<SyncRecord<RowType>>) : Promise<void>;

    insertIfRecent(uniqueId : string, lastModified : number, row : Omit<RowType, "uniqueId">) : Promise<boolean>;
    deleteIfRecent(uniqueId : string, lastModified : number) : Promise<boolean>;
}

export interface AbstractDatabase {
    ensureSchema() : Promise<void>;

    getLocalTable<T extends keyof LocalTables>(name : T) : LocalTable<LocalTables[T]>;
    getSyncTable<T extends keyof SyncTables>(name : T) : SyncTable<SyncTables[T]>;
}

export function createDB(platform : Tp.BasePlatform) : AbstractDatabase {
    // use database proxy if it's configured in the platform
    if (platform.hasCapability('database-proxy'))
        return new DatabaseProxy(platform.getCapability('database-proxy') as DatabaseProxyConfig);

    const sqliteplatform = platform as SQLitePlatform;
    return new SQLiteDatabase(sqliteplatform);
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2021 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	import * as Tp from 'thingpedia';
22
23	import { SQLiteDatabase, SQLitePlatform } from './sqlite';	97✔
24	import { DatabaseProxy, DatabaseProxyConfig } from './dbproxy';	97✔
25
26	export interface AbstractRow {
27	uniqueId : string;
28	}
29
30	export interface AppRow {
31	uniqueId : string;
32	code : string;
33	state : string;
34	name : string;
35	description : string;
36	}
37
38	export interface ChannelRow {
39	uniqueId : string;
40	value : string;
41	}
42
43	export interface DeviceRow {
44	uniqueId : string;
45	state : string;
46	}
47
48	export interface ConversationRow {
49	uniqueId : string;
50	conversationId : string;
51	previousId : string\|null;
52	dialogueId : string;
53	context : string\|null;
54	agent : string\|null;
55	agentTimestamp : string\|null;
56	agentTarget : string\|null;
57	intermediateContext : string\|null;
58	user : string;
59	userTimestamp : string\|null;
60	userTarget : string;
61	}
62
63	export interface LocalTables {
64	app : AppRow;
65	channel : ChannelRow;
66	conversation : ConversationRow;
67	}
68
69	export interface SyncTables {
70	device : DeviceRow;
71	}
72
73	export interface LocalTable<RowType extends AbstractRow> {
74	name : string;
75
76	getAll() : Promise<RowType[]>;
77	getOne(uniqueId : string) : Promise<RowType\|undefined>;
78	insertOne(uniqueId : string, row : Omit<RowType, "uniqueId">) : Promise<void>;
79	deleteOne(uniqueId : string) : Promise<void>;
80	}
81
82	export type SyncRecord<RowType> = { [K in keyof RowType] : RowType[K]\|null } & { uniqueId : string; lastModified : number };
83	export interface SyncAtReply<RowType> {
84	lastModified : number;
85	ourChanges : Array<SyncRecord<RowType>>;
86	done : boolean[];
87	}
88
89	export interface SyncTable<RowType extends AbstractRow>{
90	name : string;
91	fields : ReadonlyArray<keyof RowType>;
92
93	getAll() : Promise<RowType[]>;
94	getOne(uniqueId : string) : Promise<RowType\|undefined>;
95	insertOne(uniqueId : string, row : Omit<RowType, "uniqueId">) : Promise<number>;
96	deleteOne(uniqueId : string) : Promise<number>;
97
98	getRaw() : Promise<Array<SyncRecord<RowType>>>;
99	getChangesAfter(lastModified : number) : Promise<Array<SyncRecord<RowType>>>;
100	handleChanges(changes : Array<SyncRecord<RowType>>) : Promise<boolean[]>;
101	syncAt(lastModified : number, pushedChanges : Array<SyncRecord<RowType>>) : Promise<SyncAtReply<RowType>>;
102	replaceAll(data : Array<SyncRecord<RowType>>) : Promise<void>;
103
104	insertIfRecent(uniqueId : string, lastModified : number, row : Omit<RowType, "uniqueId">) : Promise<boolean>;
105	deleteIfRecent(uniqueId : string, lastModified : number) : Promise<boolean>;
106	}
107
108	export interface AbstractDatabase {
109	ensureSchema() : Promise<void>;
110
111	getLocalTable<T extends keyof LocalTables>(name : T) : LocalTable<LocalTables[T]>;
112	getSyncTable<T extends keyof SyncTables>(name : T) : SyncTable<SyncTables[T]>;
113	}
114
115	export function createDB(platform : Tp.BasePlatform) : AbstractDatabase {	97✔
116	// use database proxy if it's configured in the platform
117	if (platform.hasCapability('database-proxy'))	5!
UNCOV 118	return new DatabaseProxy(platform.getCapability('database-proxy') as DatabaseProxyConfig);	×
119
120	const sqliteplatform = platform as SQLitePlatform;	5✔
121	return new SQLiteDatabase(sqliteplatform);	5✔
122	}

stanford-oval / genie-toolkit / 2119

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous