210736947

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/AndreasSko/go-jwlm/commit/<a class=hub.com/AndreasSko/go-jwlm/commit/2d4f0250d167425c1e547ffdb7e5883f127fa44b">2d4f0250d<a href="https://github.com/AndreasSko/go-jwlm/commit/2d4f0250d167425c1e547ffdb7e5883f127fa44b">">Merge </a><a class="double-link" href="https://github.com/AndreasSko/go-jwlm/commit/<a class="double-link" href="https://github.com/AndreasSko/go-jwlm/commit/4c88b71812f4136b07ea791df10a47c566a89c1e">4c88b7181</a>">4c88b7181</a><a href="https://github.com/AndreasSko/go-jwlm/commit/2d4f0250d167425c1e547ffdb7e5883f127fa44b"> into 613fd82ad">613fd82ad</a>

Pull Request Pull Request #3: Export Database{} to .jwlibrary file

Run Details

349 of 349 new or added lines in 6 files covered. (100.0%)

429 of 655 relevant lines covered (65.5%)

11.02 hits per line

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

79.31

/model/manifest.go

package model

import (
        "crypto/sha256"
        "encoding/json"
        "fmt"
        "io"
        "io/ioutil"
        "log"
        "os"
        "path/filepath"
        "time"

        "github.com/pkg/errors"
)

type manifest struct {
        CreationDate   string         `json:"creationDate"`
        UserDataBackup userDataBackup `json:"userDataBackup"`
        Name           string         `json:"name"`
        Type           int            `json:"type"`
        Version        int            `json:"version"`
}
type userDataBackup struct {
        LastModifiedDate string `json:"lastModifiedDate"`
        Hash             string `json:"hash"`
        DatabaseName     string `json:"databaseName"`
        SchemaVersion    int    `json:"schemaVersion"`
        DeviceName       string `json:"deviceName"`
}

// validateManifest checks if the backup file is compatible by validating its manifest.json
func validateManifest(path string) error {
        const version = 1
        const schemaVersion = 8

        file, err := os.Open(path)
        if err != nil {
                return err
        }
        defer file.Close()

        blob, _ := ioutil.ReadAll(file)

        var manifest manifest
        err = json.Unmarshal([]byte(blob), &manifest)
        if err != nil {
                return errors.Wrap(err, "Could not unmarshall backup manifest file")
        }

        if manifest.Version != version {
                return fmt.Errorf("Manifest version is incompatible. Should be %d is %d", version, manifest.Version)
        }

        if manifest.UserDataBackup.SchemaVersion != schemaVersion {
                return fmt.Errorf("Schema version is incompatible. Should be %d is %d", schemaVersion, manifest.UserDataBackup.SchemaVersion)
        }

        return nil
}

// createManifest creates a manifest for a given SQLite database and saves it at path
func createManifest(backupName string, dbFile string, path string) error {
        // Get SHA256 of SQLite file
        f, err := os.Open(dbFile)
        if err != nil {
                errors.Wrap(err, "Error while opening SQLite file to calculate hash")
        }
        defer f.Close()
        hasher := sha256.New()
        if _, err := io.Copy(hasher, f); err != nil {
                log.Fatal(err)
        }
        hash := fmt.Sprintf("%x", hasher.Sum(nil))

        udb := userDataBackup{
                LastModifiedDate: time.Now().Format("2006-01-02T15:04:05-07:00"),
                Hash:             hash,
                DatabaseName:     filepath.Base(dbFile),
                SchemaVersion:    8,
                DeviceName:       "go-jwlm",
        }

        manifest := manifest{
                CreationDate:   time.Now().Format("2006-01-02"),
                UserDataBackup: udb,
                Name:           backupName,
                Type:           0,
                Version:        1,
        }

        bytes, err := json.Marshal(manifest)
        if err := ioutil.WriteFile(path, bytes, 0644); err != nil {
                return errors.Wrap(err, fmt.Sprintf("Error while saving manifest file to %v", path))
        }

        return nil
}

1	package model
2
3	import (
4	"crypto/sha256"
5	"encoding/json"
6	"fmt"
7	"io"
8	"io/ioutil"
9	"log"
10	"os"
11	"path/filepath"
12	"time"
13
14	"github.com/pkg/errors"
15	)
16
17	type manifest struct {
18	CreationDate string `json:"creationDate"`
19	UserDataBackup userDataBackup `json:"userDataBackup"`
20	Name string `json:"name"`
21	Type int `json:"type"`
22	Version int `json:"version"`
23	}
24	type userDataBackup struct {
25	LastModifiedDate string `json:"lastModifiedDate"`
26	Hash string `json:"hash"`
27	DatabaseName string `json:"databaseName"`
28	SchemaVersion int `json:"schemaVersion"`
29	DeviceName string `json:"deviceName"`
30	}
31
32	// validateManifest checks if the backup file is compatible by validating its manifest.json
33	func validateManifest(path string) error {	5✔
34	const version = 1	5✔
35	const schemaVersion = 8	5✔
36		5✔
37	file, err := os.Open(path)	5✔
38	if err != nil {	6✔
39	return err	1✔
40	}	1✔
41	defer file.Close()	4✔
42		4✔
43	blob, _ := ioutil.ReadAll(file)	4✔
44		4✔
45	var manifest manifest	4✔
46	err = json.Unmarshal([]byte(blob), &manifest)	4✔
47	if err != nil {	4✔
48	return errors.Wrap(err, "Could not unmarshall backup manifest file")	×
49	}	×
50
51	if manifest.Version != version {	4✔
52	return fmt.Errorf("Manifest version is incompatible. Should be %d is %d", version, manifest.Version)	×
53	}	×
54
55	if manifest.UserDataBackup.SchemaVersion != schemaVersion {	4✔
56	return fmt.Errorf("Schema version is incompatible. Should be %d is %d", schemaVersion, manifest.UserDataBackup.SchemaVersion)	×
57	}	×
58
59	return nil	4✔
60	}
61
62	// createManifest creates a manifest for a given SQLite database and saves it at path
63	func createManifest(backupName string, dbFile string, path string) error {	1✔
64	// Get SHA256 of SQLite file	1✔
65	f, err := os.Open(dbFile)	1✔
66	if err != nil {	1✔
67	errors.Wrap(err, "Error while opening SQLite file to calculate hash")	×
68	}	×
69	defer f.Close()	1✔
70	hasher := sha256.New()	1✔
71	if _, err := io.Copy(hasher, f); err != nil {	1✔
72	log.Fatal(err)	×
73	}	×
74	hash := fmt.Sprintf("%x", hasher.Sum(nil))	1✔
75		1✔
76	udb := userDataBackup{	1✔
77	LastModifiedDate: time.Now().Format("2006-01-02T15:04:05-07:00"),	1✔
78	Hash: hash,	1✔
79	DatabaseName: filepath.Base(dbFile),	1✔
80	SchemaVersion: 8,	1✔
81	DeviceName: "go-jwlm",	1✔
82	}	1✔
83		1✔
84	manifest := manifest{	1✔
85	CreationDate: time.Now().Format("2006-01-02"),	1✔
86	UserDataBackup: udb,	1✔
87	Name: backupName,	1✔
88	Type: 0,	1✔
89	Version: 1,	1✔
90	}	1✔
91		1✔
92	bytes, err := json.Marshal(manifest)	1✔
93	if err := ioutil.WriteFile(path, bytes, 0644); err != nil {	1✔
94	return errors.Wrap(err, fmt.Sprintf("Error while saving manifest file to %v", path))	×
95	}	×
96
97	return nil	1✔
98	}

AndreasSko / go-jwlm / 210736947

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