From 2b888f203d08d5713c0fdb5e08ef06d6844ab101 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Thu, 12 Sep 2024 16:40:31 -0500 Subject: [PATCH 01/22] =?UTF-8?q?=F0=9F=9A=A7=20A=20bit=20of=20initial=20w?= =?UTF-8?q?ork?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app.go | 69 +++++++++++++++++++++++++ cmd/lenore/main.go | 44 +++++++++++++++- config/config.go | 6 +++ config/env.go | 37 ++++++++++++++ go.mod | 45 ++++++++++++++++ go.sum | 124 +++++++++++++++++++++++++++++++++++++++++++++ storage/.gitignore | 2 + 7 files changed, 326 insertions(+), 1 deletion(-) create mode 100644 app.go create mode 100644 config/config.go create mode 100644 config/env.go create mode 100644 go.sum create mode 100644 storage/.gitignore diff --git a/app.go b/app.go new file mode 100644 index 0000000..2823557 --- /dev/null +++ b/app.go @@ -0,0 +1,69 @@ +package lenore + +import ( + "errors" + "fmt" + + "codeberg.org/danjones000/lenore/config" + vocab "github.com/go-ap/activitypub" + "github.com/go-ap/client" + boxap "github.com/go-ap/fedbox/activitypub" + proc "github.com/go-ap/processing" +) + +type App struct { + conf config.Config + self vocab.Service + user vocab.Person + version string + storage proc.Store + client client.C +} + +func NewApp(ver string, conf config.Config, db proc.Store) (*App, error) { + if conf.BaseURL == "" { + return nil, errors.New("Missing BaseURL") + } + app := App{ + version: ver, + } + + selfIRI := boxap.DefaultServiceIRI(conf.BaseURL) + self, err := boxap.LoadActor(db, selfIRI) + if err != nil { + return nil, err + } + + app.self = self + app.client = *client.New() + + return &app, nil +} + +func (l *App) Config() config.Config { + return l.conf +} + +func (l *App) Storage() proc.Store { + return l.storage +} + +func (l *App) Service() vocab.Service { + return l.self +} + +func (l *App) ServiceIRI() vocab.IRI { + return l.self.ID +} + +func (l *App) User() vocab.Actor { + return l.user +} + +func (l *App) Version() string { + return l.version +} + +func (l *App) String() string { + return fmt.Sprintf("Lenore (%s)", l.version) +} diff --git a/cmd/lenore/main.go b/cmd/lenore/main.go index 7905807..f879352 100644 --- a/cmd/lenore/main.go +++ b/cmd/lenore/main.go @@ -1,5 +1,47 @@ package main -func main() { +// @todo +import ( + "fmt" + "time" + + "codeberg.org/danjones000/lenore" + "codeberg.org/danjones000/lenore/config" + vocab "github.com/go-ap/activitypub" + boxap "github.com/go-ap/fedbox/activitypub" + "github.com/go-ap/storage-sqlite" +) + +func main() { + conf := config.Config{BaseURL: "http://localhost:4523/"} + + sqlConf := sqlite.Config{Path: "storage"} + err := sqlite.Bootstrap(sqlConf) + if err != nil { + panic(err) + } + + db, err := sqlite.New(sqlConf) + if err != nil { + panic(err) + } + + serv := vocab.ServiceNew(boxap.DefaultServiceIRI(conf.BaseURL)) + serv.Name = vocab.DefaultNaturalLanguageValue("Lenore") + serv.Summary = vocab.DefaultNaturalLanguageValue("ActivityPub-powered reader") + serv.Published = time.Now() + serv.Updated = time.Now() + _, err = db.Save(serv) + if err != nil { + panic(err) + } + + app, err := lenore.NewApp("0.0.0", conf, db) + if err != nil { + panic(err) + } + + fmt.Println(app) + fmt.Println(app.Service().ID) } diff --git a/config/config.go b/config/config.go new file mode 100644 index 0000000..835d7f7 --- /dev/null +++ b/config/config.go @@ -0,0 +1,6 @@ +package config + +type Config struct { + Env Env + BaseURL string +} diff --git a/config/env.go b/config/env.go new file mode 100644 index 0000000..99f8aa0 --- /dev/null +++ b/config/env.go @@ -0,0 +1,37 @@ +package config + +type Env string + +const ( + DEV Env = "dev" + PROD Env = "prod" + QA Env = "qa" + TEST Env = "test" +) + +var Envs = [...]Env{ + DEV, + PROD, + QA, + TEST, +} + +func ValidEnvOrDev(e Env) Env { + if ValidEnv(e) { + return e + } + return DEV +} + +func ValidEnv(env Env) bool { + for _, e := range Envs { + if env == e { + return true + } + } + return false +} + +func (e Env) String() string { + return string(e) +} diff --git a/go.mod b/go.mod index 3947c9d..1704bf7 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,48 @@ module codeberg.org/danjones000/lenore go 1.23.1 + +require ( + github.com/go-ap/activitypub v0.0.0-20240910141749-b4b8c8aa484c + github.com/go-ap/client v0.0.0-20240910141951-13a4f3c4fd53 + github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399 + github.com/go-ap/processing v0.0.0-20240910151355-8284a5ce9c22 + github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa +) + +require ( + git.sr.ht/~mariusor/cache v0.0.0-20240905174905-d68f888f114e // indirect + git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078 // indirect + git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120 // indirect + git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-ap/cache v0.0.0-20240910141827-94f8ac1a9133 // indirect + github.com/go-ap/errors v0.0.0-20240910140019-1e9d33cc1568 // indirect + github.com/go-ap/filters v0.0.0-20240910141936-c8f68cdf2bc9 // indirect + github.com/go-ap/jsonld v0.0.0-20221030091449-f2a191312c73 // indirect + github.com/go-chi/chi/v5 v5.1.0 // indirect + github.com/go-fed/httpsig v1.1.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect + github.com/mariusor/qstring v0.0.0-20200204164351-5a99d46de39d // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-sqlite3 v1.14.23 // indirect + github.com/ncruces/go-strftime v0.1.9 // indirect + github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f // indirect + github.com/pborman/uuid v1.2.1 // indirect + github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + github.com/rs/xid v1.6.0 // indirect + github.com/rs/zerolog v1.33.0 // indirect + github.com/valyala/fastjson v1.6.4 // indirect + golang.org/x/crypto v0.27.0 // indirect + golang.org/x/oauth2 v0.23.0 // indirect + golang.org/x/sys v0.25.0 // indirect + golang.org/x/text v0.18.0 // indirect + modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a // indirect + modernc.org/mathutil v1.6.0 // indirect + modernc.org/memory v1.8.0 // indirect + modernc.org/sqlite v1.33.0 // indirect + modernc.org/strutil v1.2.0 // indirect + modernc.org/token v1.1.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..9637828 --- /dev/null +++ b/go.sum @@ -0,0 +1,124 @@ +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +git.sr.ht/~mariusor/cache v0.0.0-20240905174905-d68f888f114e h1:JmQa0+xdOJFmXmxeBPg5SuFyqA5/4YBwooYCJIefpWk= +git.sr.ht/~mariusor/cache v0.0.0-20240905174905-d68f888f114e/go.mod h1:Yv1mSKccec0/7Jn75Zx03n7nt2SGccoX9E9jLOA62Hw= +git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078 h1:cliQ4HHsCo6xi2oWZYKWW4bly/Ory9FuTpFPRxj/mAg= +git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078/go.mod h1:g/V2Hjas6Z1UHUp4yIx6bATpNzJ7DYtD0FG3+xARWxs= +git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120 h1:OLxL9lel79BV3EHu/AMU+DtcuOnHnb3OjrLyF7NbE1w= +git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120/go.mod h1:kXJ4JsgGBu7IVBKlrVvGjSLJmpsAGqZwq/JU/kTUaLw= +git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7 h1:bCGvett+MiEDc5L+T9jByp671KnKRG/iJCCm0fc+21s= +git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7/go.mod h1:VApG24PG5Ij+tw5zpN5O61FSQU9gJK/cYQwFYM+kkwA= +github.com/carlmjohnson/be v0.23.2 h1:1QjPnPJhwGUjsD9+7h98EQlKsxnG5TV+nnEvk0wnkls= +github.com/carlmjohnson/be v0.23.2/go.mod h1:KAgPUh0HpzWYZZI+IABdo80wTgY43YhbdsiLYAaSI/Q= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/go-ap/activitypub v0.0.0-20240910141749-b4b8c8aa484c h1:82lzmsy5Nr6JA6HcLRVxGfbdSoWfW45C6jnY3zFS7Ks= +github.com/go-ap/activitypub v0.0.0-20240910141749-b4b8c8aa484c/go.mod h1:rpIPGre4qtTgSpVT0zz3hycAMuLtUt7BNngVNpyXhL8= +github.com/go-ap/cache v0.0.0-20240910141827-94f8ac1a9133 h1:m4kbmmgtUwk0cSqqysf5aPwX4cd9Q2MEXCiZ+8sLAB0= +github.com/go-ap/cache v0.0.0-20240910141827-94f8ac1a9133/go.mod h1:fFBwyje1EwOeMO588u+V0sND5SN94G6MhuNwQOrpPSA= +github.com/go-ap/client v0.0.0-20240910141951-13a4f3c4fd53 h1:wHUTCltRHg+Uz24+Ym1Bz5AE/0mnIKjzbdcPU9MKH1Y= +github.com/go-ap/client v0.0.0-20240910141951-13a4f3c4fd53/go.mod h1:9VAgCNIP146tYVV5mA1OyoMGpxIUo9DSx7XLZFcZin0= +github.com/go-ap/errors v0.0.0-20240910140019-1e9d33cc1568 h1:eQEXAzWEijFbwtm/Hr2EtFbM0LvATRd1ltpDb+mfjQk= +github.com/go-ap/errors v0.0.0-20240910140019-1e9d33cc1568/go.mod h1:Vkh+Z3f24K8nMsJKXo1FHn5ebPsXvB/WDH5JRtYqdNo= +github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399 h1:exxqQ+fu5u8SQGLNh+26o7dJXetisjfCEgwERK4Pquw= +github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399/go.mod h1:forbKJptQWYoG7HJesrzxeIgod0jCEBm6q9mlU0qTBY= +github.com/go-ap/filters v0.0.0-20240910141936-c8f68cdf2bc9 h1:OYaAekA5CRlyERVY7iHKbj5HunEhbhk0dzIlPo8sVJg= +github.com/go-ap/filters v0.0.0-20240910141936-c8f68cdf2bc9/go.mod h1:MhJ7+3WJ2/ckcVi+2I7awydLT6diYoZTz6FokpDIYLw= +github.com/go-ap/jsonld v0.0.0-20221030091449-f2a191312c73 h1:GMKIYXyXPGIp+hYiWOhfqK4A023HdgisDT4YGgf99mw= +github.com/go-ap/jsonld v0.0.0-20221030091449-f2a191312c73/go.mod h1:jyveZeGw5LaADntW+UEsMjl3IlIwk+DxlYNsbofQkGA= +github.com/go-ap/processing v0.0.0-20240910151355-8284a5ce9c22 h1:tbMqrM1fxIKR0ml2DzPr7JI8h8io9gJMKQtpH/SMZ7k= +github.com/go-ap/processing v0.0.0-20240910151355-8284a5ce9c22/go.mod h1:fUIzD9DAMXw1ZJN2PVLFU5mfqDibnPDj3e1d7cNxRGo= +github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa h1:O1StIx92J3cXJNzcbvjGjtunvJVgpdBpKZL+48EgOUU= +github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa/go.mod h1:KYODCEwUFfaGSwG22KBG1MNMVTkc278pfRMmZRqE9NA= +github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw= +github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= +github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI= +github.com/go-fed/httpsig v1.1.0/go.mod h1:RCMrTZvN1bJYtofsG4rd5NaO5obxQ5xBkdiS7xsT7bM= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo= +github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= +github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/mariusor/qstring v0.0.0-20200204164351-5a99d46de39d h1:bkd9X98bkucj5wlCsgTYHPx4NYoc6tUzSbmyZXOrnl4= +github.com/mariusor/qstring v0.0.0-20200204164351-5a99d46de39d/go.mod h1:WYcWf5qC9oospJOziIantsuqCcbWheB5zQ5FI60W3kU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-sqlite3 v1.14.23 h1:gbShiuAP1W5j9UOksQ06aiiqPMxYecovVGwmTxWtuw0= +github.com/mattn/go-sqlite3 v1.14.23/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= +github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= +github.com/openshift/build-machinery-go v0.0.0-20200917070002-f171684f77ab/go.mod h1:b1BuldmJlbA/xYtdZvKi+7j5YGB44qJUJDZ9zwiNCfE= +github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f h1:4da9vH8eDlJo58703cADj3FlsdnFRgsnfuwj/4lYXfY= +github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f/go.mod h1:DoYehsADYGKlXTIvqyZVnopfJbWgT6UsQYf8ETt1vjw= +github.com/openshift/osincli v0.0.0-20160924135400-fababb0555f2/go.mod h1:Riv9DbfKiX3y9ebcS4PHU4zLhVXu971+4jCVwKIue5M= +github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= +github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw= +github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= +github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= +github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ= +github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= +golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/mod v0.20.0 h1:utOm6MM3R3dnawAiJgn0y+xvuYRsm1RKM/4giyfDgV0= +golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs= +golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= +golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM= +golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= +golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg= +golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +gopkg.in/square/go-jose.v1 v1.1.2/go.mod h1:QpYS+a4WhS+DTlyQIi6Ka7MS3SuR9a055rgXNEe6EiA= +modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE= +modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ= +modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a h1:CfbpOLEo2IwNzJdMvE8aiRbPMxoTpgAJeyePh0SmO8M= +modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= +modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= +modernc.org/sqlite v1.33.0 h1:WWkA/T2G17okiLGgKAj4/RMIvgyMT19yQ038160IeYk= +modernc.org/sqlite v1.33.0/go.mod h1:9uQ9hF/pCZoYZK73D/ud5Z7cIRIILSZI8NdIemVMTX8= +modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= +modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= +modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= diff --git a/storage/.gitignore b/storage/.gitignore new file mode 100644 index 0000000..d6b7ef3 --- /dev/null +++ b/storage/.gitignore @@ -0,0 +1,2 @@ +* +!.gitignore From e441e541c72bc0bd246719eac09c2f3ca8296188 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Fri, 13 Sep 2024 13:38:30 -0500 Subject: [PATCH 02/22] =?UTF-8?q?=E2=9C=85=20Test=20config?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/config.go | 4 +++ config/config_test.go | 26 +++++++++++++++++++ config/env_test.go | 59 +++++++++++++++++++++++++++++++++++++++++++ go.mod | 4 +++ go.sum | 8 ++++++ 5 files changed, 101 insertions(+) create mode 100644 config/config_test.go create mode 100644 config/env_test.go diff --git a/config/config.go b/config/config.go index 835d7f7..33c2e54 100644 --- a/config/config.go +++ b/config/config.go @@ -4,3 +4,7 @@ type Config struct { Env Env BaseURL string } + +func (c Config) Environment() Env { + return ValidEnvOrDev(c.Env) +} diff --git a/config/config_test.go b/config/config_test.go new file mode 100644 index 0000000..2586018 --- /dev/null +++ b/config/config_test.go @@ -0,0 +1,26 @@ +package config + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestEnvDefaultsToDev(t *testing.T) { + c := Config{} + assert.Equal(t, DEV, c.Environment()) +} + +func TestInvalidEnvReturnsDev(t *testing.T) { + c := Config{Env: Env("foobar")} + assert.Equal(t, DEV, c.Environment()) +} + +func TestValidEnvReturnsCorrect(t *testing.T) { + for _, e := range Envs { + t.Run(string(e), func(t *testing.T) { + c := Config{Env: e} + assert.Equal(t, e, c.Environment()) + }) + } +} diff --git a/config/env_test.go b/config/env_test.go new file mode 100644 index 0000000..2084c0a --- /dev/null +++ b/config/env_test.go @@ -0,0 +1,59 @@ +package config + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestEnvString(t *testing.T) { + cases := Envs[:] + cases = append(cases, Env("foobar"), Env(""), Env("42"), Env("✨")) + for _, e := range cases { + t.Run(string(e), func(t *testing.T) { + assert.Equal(t, string(e), e.String()) + }) + } +} + +func TestValidEnv(t *testing.T) { + cases := [...]struct { + e Env + exp bool + }{ + {DEV, true}, + {PROD, true}, + {QA, true}, + {TEST, true}, + {Env("foobar"), false}, + {Env(""), false}, + {Env("✨"), false}, + } + + for _, c := range cases { + t.Run(string(c.e), func(t *testing.T) { + assert.Equal(t, c.exp, ValidEnv(c.e)) + }) + } +} + +func TestValidEnvOrDev(t *testing.T) { + cases := [...]struct { + give Env + exp Env + }{ + {DEV, DEV}, + {PROD, PROD}, + {QA, QA}, + {TEST, TEST}, + {Env("foobar"), DEV}, + {Env(""), DEV}, + {Env("✨"), DEV}, + } + + for _, c := range cases { + t.Run(string(c.give), func(t *testing.T) { + assert.Equal(t, c.exp, ValidEnvOrDev(c.give)) + }) + } +} diff --git a/go.mod b/go.mod index 1704bf7..418bc6a 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399 github.com/go-ap/processing v0.0.0-20240910151355-8284a5ce9c22 github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa + github.com/stretchr/testify v1.9.0 ) require ( @@ -15,6 +16,7 @@ require ( git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078 // indirect git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120 // indirect git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/go-ap/cache v0.0.0-20240910141827-94f8ac1a9133 // indirect github.com/go-ap/errors v0.0.0-20240910140019-1e9d33cc1568 // indirect @@ -31,6 +33,7 @@ require ( github.com/ncruces/go-strftime v0.1.9 // indirect github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f // indirect github.com/pborman/uuid v1.2.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rs/xid v1.6.0 // indirect github.com/rs/zerolog v1.33.0 // indirect @@ -39,6 +42,7 @@ require ( golang.org/x/oauth2 v0.23.0 // indirect golang.org/x/sys v0.25.0 // indirect golang.org/x/text v0.18.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a // indirect modernc.org/mathutil v1.6.0 // indirect modernc.org/memory v1.8.0 // indirect diff --git a/go.sum b/go.sum index 9637828..617a50d 100644 --- a/go.sum +++ b/go.sum @@ -10,6 +10,8 @@ git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7/go.mod h1:VApG24PG5Ij github.com/carlmjohnson/be v0.23.2 h1:1QjPnPJhwGUjsD9+7h98EQlKsxnG5TV+nnEvk0wnkls= github.com/carlmjohnson/be v0.23.2/go.mod h1:KAgPUh0HpzWYZZI+IABdo80wTgY43YhbdsiLYAaSI/Q= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= @@ -75,6 +77,8 @@ github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ= github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= @@ -107,7 +111,11 @@ golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg= golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/square/go-jose.v1 v1.1.2/go.mod h1:QpYS+a4WhS+DTlyQIi6Ka7MS3SuR9a055rgXNEe6EiA= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE= modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ= modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a h1:CfbpOLEo2IwNzJdMvE8aiRbPMxoTpgAJeyePh0SmO8M= From 6498f3d56b64495cf559350d5f9bb8fc4c1dc210 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Fri, 13 Sep 2024 17:45:06 -0500 Subject: [PATCH 03/22] =?UTF-8?q?=E2=9C=85=20Test=20app?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app.go | 16 ++++++- app_test.go | 89 +++++++++++++++++++++++++++++++++++++ config/config.go | 1 + internal/testmocks/store.go | 38 ++++++++++++++++ 4 files changed, 142 insertions(+), 2 deletions(-) create mode 100644 app_test.go create mode 100644 internal/testmocks/store.go diff --git a/app.go b/app.go index 2823557..c4b89ce 100644 --- a/app.go +++ b/app.go @@ -26,6 +26,7 @@ func NewApp(ver string, conf config.Config, db proc.Store) (*App, error) { } app := App{ version: ver, + conf: conf, } selfIRI := boxap.DefaultServiceIRI(conf.BaseURL) @@ -44,6 +45,10 @@ func (l *App) Config() config.Config { return l.conf } +func (l *App) Environment() config.Env { + return l.conf.Environment() +} + func (l *App) Storage() proc.Store { return l.storage } @@ -64,6 +69,13 @@ func (l *App) Version() string { return l.version } -func (l *App) String() string { - return fmt.Sprintf("Lenore (%s)", l.version) +func (l *App) Name() string { + if l.conf.Name == "" { + return "Lenore" + } + return l.conf.Name +} + +func (l *App) String() string { + return fmt.Sprintf("%s (%s)", l.Name(), l.version) } diff --git a/app_test.go b/app_test.go new file mode 100644 index 0000000..7bc0cac --- /dev/null +++ b/app_test.go @@ -0,0 +1,89 @@ +package lenore + +import ( + "fmt" + "testing" + + "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/lenore/internal/testmocks" + vocab "github.com/go-ap/activitypub" + "github.com/stretchr/testify/assert" +) + +func TestEmptyBaseURL(t *testing.T) { + c := config.Config{} + a, er := NewApp("0.0.0", c, testmocks.GetStore()) + assert.Nil(t, a) + assert.EqualError(t, er, "Missing BaseURL") +} + +func TestDefaultEnvironment(t *testing.T) { + c := config.Config{BaseURL: "http://localhost:1234/"} + a, er := NewApp("0.0.0", c, testmocks.GetStore()) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Equal(t, config.DEV, a.Environment()) + } +} + +func TestGivenEnvironment(t *testing.T) { + cases := [...]struct { + given config.Env + exp config.Env + }{ + {config.DEV, config.DEV}, + {config.PROD, config.PROD}, + {config.QA, config.QA}, + {config.Env("foo"), config.DEV}, + {config.Env("✨"), config.DEV}, + } + + for _, c := range cases { + t.Run(string(c.given), func(t *testing.T) { + conf := config.Config{BaseURL: "http://localhost:1234/", Env: c.given} + a, er := NewApp("0.0.0", conf, testmocks.GetStore()) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Equal(t, conf, a.Config()) + assert.Equal(t, c.exp, a.Environment()) + } + }) + } +} + +func TestService(t *testing.T) { + base := "http://localhost:1234/" + conf := config.Config{BaseURL: base} + a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Equal(t, vocab.IRI(base), a.ServiceIRI()) + assert.Equal(t, vocab.IRI(base), a.Service().ID) + } +} + +func TestStrings(t *testing.T) { + cases := [...]struct { + given string + exp string + }{ + {"", "Lenore"}, + {"Lenore", "Lenore"}, + {"Danny Ray", "Danny Ray"}, + {"✨👹", "✨👹"}, + } + + for _, c := range cases { + t.Run(c.given, func(t *testing.T) { + conf := config.Config{BaseURL: "http://localhost:1234/", Name: c.given} + expStr := fmt.Sprintf("%s (%s)", c.exp, "0.0.0.0") + a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Equal(t, c.exp, a.Name()) + assert.Equal(t, "0.0.0.0", a.Version()) + assert.Equal(t, expStr, a.String()) + } + }) + } +} diff --git a/config/config.go b/config/config.go index 33c2e54..a0125fb 100644 --- a/config/config.go +++ b/config/config.go @@ -1,6 +1,7 @@ package config type Config struct { + Name string Env Env BaseURL string } diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go new file mode 100644 index 0000000..9cdccb7 --- /dev/null +++ b/internal/testmocks/store.go @@ -0,0 +1,38 @@ +package testmocks + +import ( + vocab "github.com/go-ap/activitypub" + "github.com/go-ap/filters" + proc "github.com/go-ap/processing" +) + +type st struct{} + +func (s *st) Load(iri vocab.IRI, filters ...filters.Check) (vocab.Item, error) { + i := vocab.ActorNew(iri, vocab.ActorType) + return i, nil +} + +func (s *st) Save(v vocab.Item) (vocab.Item, error) { + return v, nil +} + +func (s *st) Delete(v vocab.Item) error { + return nil +} + +func (s *st) Create(col vocab.CollectionInterface) (vocab.CollectionInterface, error) { + return col, nil +} + +func (s *st) AddTo(col vocab.IRI, it vocab.Item) error { + return nil +} + +func (s *st) RemoveFrom(col vocab.IRI, it vocab.Item) error { + return nil +} + +func GetStore() proc.Store { + return &st{} +} From 33f140595cc78c631ed7d4d906a4c7ad485627d0 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 09:45:35 -0500 Subject: [PATCH 04/22] =?UTF-8?q?=F0=9F=9B=A0=20Add=20Taskfile?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Taskfile.yml diff --git a/Taskfile.yml b/Taskfile.yml new file mode 100644 index 0000000..2b381c7 --- /dev/null +++ b/Taskfile.yml @@ -0,0 +1,25 @@ +version: '3' + +tasks: + default: + cmds: + - task: fmt + - task: test + - task: build + + fmt: + desc: Format go code + cmds: + - go fmt ./... + + test: + desc: Run unit tests + cmds: + - go test -race -cover ./... + + build: + desc: Build server binary + generates: + - build/lenore + cmds: + - go build -o build/lenore cmd/lenore/main.go From 0e2d302804b10f65ea08800755f04582b5e1014e Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 11:25:02 -0500 Subject: [PATCH 05/22] =?UTF-8?q?=F0=9F=9B=A0=20Cache=20build?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 1 + Taskfile.yml | 2 ++ 2 files changed, 3 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f1c37ad --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.task/ diff --git a/Taskfile.yml b/Taskfile.yml index 2b381c7..6b8852f 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -19,6 +19,8 @@ tasks: build: desc: Build server binary + sources: + - '**/*.go' generates: - build/lenore cmds: From bdc625b57e44431196f10ee6e76c571a4e3a5974 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 11:27:28 -0500 Subject: [PATCH 06/22] =?UTF-8?q?=F0=9F=92=A5=20Add=20store?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app.go | 8 +++--- internal/testmocks/store.go | 7 +++-- internal/testmocks/store_meta.go | 20 +++++++++++++ internal/testmocks/store_osin_auth.go | 37 +++++++++++++++++++++++++ internal/testmocks/store_osin_client.go | 30 ++++++++++++++++++++ store/store.go | 31 +++++++++++++++++++++ 6 files changed, 127 insertions(+), 6 deletions(-) create mode 100644 internal/testmocks/store_meta.go create mode 100644 internal/testmocks/store_osin_auth.go create mode 100644 internal/testmocks/store_osin_client.go create mode 100644 store/store.go diff --git a/app.go b/app.go index c4b89ce..6390de9 100644 --- a/app.go +++ b/app.go @@ -5,10 +5,10 @@ import ( "fmt" "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/lenore/store" vocab "github.com/go-ap/activitypub" "github.com/go-ap/client" boxap "github.com/go-ap/fedbox/activitypub" - proc "github.com/go-ap/processing" ) type App struct { @@ -16,11 +16,11 @@ type App struct { self vocab.Service user vocab.Person version string - storage proc.Store + storage store.Store client client.C } -func NewApp(ver string, conf config.Config, db proc.Store) (*App, error) { +func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { if conf.BaseURL == "" { return nil, errors.New("Missing BaseURL") } @@ -49,7 +49,7 @@ func (l *App) Environment() config.Env { return l.conf.Environment() } -func (l *App) Storage() proc.Store { +func (l *App) Storage() store.Store { return l.storage } diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go index 9cdccb7..a7ae185 100644 --- a/internal/testmocks/store.go +++ b/internal/testmocks/store.go @@ -1,9 +1,9 @@ package testmocks import ( + "codeberg.org/danjones000/lenore/store" vocab "github.com/go-ap/activitypub" "github.com/go-ap/filters" - proc "github.com/go-ap/processing" ) type st struct{} @@ -33,6 +33,9 @@ func (s *st) RemoveFrom(col vocab.IRI, it vocab.Item) error { return nil } -func GetStore() proc.Store { +func (s *st) Close() { +} + +func GetStore() store.Store { return &st{} } diff --git a/internal/testmocks/store_meta.go b/internal/testmocks/store_meta.go new file mode 100644 index 0000000..316ace0 --- /dev/null +++ b/internal/testmocks/store_meta.go @@ -0,0 +1,20 @@ +package testmocks + +import ( + "crypto" + + vocab "github.com/go-ap/activitypub" + proc "github.com/go-ap/processing" +) + +func (s *st) LoadKey(vocab.IRI) (crypto.PrivateKey, error) { + return nil, nil +} + +func (s *st) LoadMetadata(vocab.IRI) (*proc.Metadata, error) { + return nil, nil +} + +func (s *st) SaveMetadata(proc.Metadata, vocab.IRI) error { + return nil +} diff --git a/internal/testmocks/store_osin_auth.go b/internal/testmocks/store_osin_auth.go new file mode 100644 index 0000000..a266cb1 --- /dev/null +++ b/internal/testmocks/store_osin_auth.go @@ -0,0 +1,37 @@ +package testmocks + +import ( + "github.com/openshift/osin" +) + +func (s *st) LoadAccess(string) (*osin.AccessData, error) { + return nil, nil +} + +func (s *st) SaveAccess(*osin.AccessData) error { + return nil +} + +func (s *st) RemoveAccess(string) error { + return nil +} + +func (s *st) LoadAuthorize(string) (*osin.AuthorizeData, error) { + return nil, nil +} + +func (s *st) SaveAuthorize(*osin.AuthorizeData) error { + return nil +} + +func (s *st) RemoveAuthorize(string) error { + return nil +} + +func (s *st) LoadRefresh(string) (*osin.AccessData, error) { + return nil, nil +} + +func (s *st) RemoveRefresh(string) error { + return nil +} diff --git a/internal/testmocks/store_osin_client.go b/internal/testmocks/store_osin_client.go new file mode 100644 index 0000000..980379d --- /dev/null +++ b/internal/testmocks/store_osin_client.go @@ -0,0 +1,30 @@ +package testmocks + +import ( + "github.com/openshift/osin" +) + +func (s *st) Clone() osin.Storage { + n := *s + return &n +} + +func (s *st) GetClient(string) (osin.Client, error) { + return &osin.DefaultClient{}, nil +} + +func (s *st) CreateClient(osin.Client) error { + return nil +} + +func (s *st) UpdateClient(osin.Client) error { + return nil +} + +func (s *st) RemoveClient(string) error { + return nil +} + +func (s *st) ListClients() (cl []osin.Client, er error) { + return +} diff --git a/store/store.go b/store/store.go new file mode 100644 index 0000000..6b5336b --- /dev/null +++ b/store/store.go @@ -0,0 +1,31 @@ +package store + +import ( + st "github.com/go-ap/fedbox/storage" + proc "github.com/go-ap/processing" + "github.com/openshift/osin" +) + +type ClientSaver interface { + // UpdateClient updates the client (identified by it's id) and replaces the values with the values of client. + UpdateClient(c osin.Client) error + // CreateClient stores the client in the database and returns an error, if something went wrong. + CreateClient(c osin.Client) error + // RemoveClient removes a client (identified by id) from the database. Returns an error if something went wrong. + RemoveClient(id string) error +} + +type ClientLister interface { + // ListClients lists existing clients + ListClients() ([]osin.Client, error) + GetClient(id string) (osin.Client, error) +} + +type Store interface { + ClientSaver + ClientLister + proc.Store + proc.KeyLoader + osin.Storage + st.MetadataTyper +} From 0fe6f5070eafb6ae463f3a7eeffc485e1b9e8d13 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 16:51:33 -0500 Subject: [PATCH 07/22] =?UTF-8?q?=F0=9F=9B=A0=20Code=20coverage?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 31 ++++++++++++++++++++++++++++++- build/.gitignore | 3 ++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/Taskfile.yml b/Taskfile.yml index 6b8852f..eb52f83 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -7,15 +7,44 @@ tasks: - task: test - task: build + ft: + desc: Format and test + cmds: + - task: fmt + - task: test + fmt: desc: Format go code + sources: + - '**/*.go' cmds: - go fmt ./... test: desc: Run unit tests + sources: + - '**/*.go' + generates: + - build/cover.out cmds: - - go test -race -cover ./... + - go test -race -cover -coverprofile build/cover.out ./... + + coverage-report: + desc: Build coverage report + deps: [test] + sources: + - build/cover.out + generates: + - build/cover.html + cmds: + - go tool cover -html=build/cover.out -o build/cover.html + + serve-report: + desc: Serve the coverage report + deps: [coverage-report] + cmds: + - ip addr list | grep inet + - php -S 0.0.0.0:3265 -t build build: desc: Build server binary diff --git a/build/.gitignore b/build/.gitignore index b1e2a80..d6b7ef3 100644 --- a/build/.gitignore +++ b/build/.gitignore @@ -1 +1,2 @@ -lenore +* +!.gitignore From 931f75500f303b1e337062f3c2f06891cd587f88 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 16:53:53 -0500 Subject: [PATCH 08/22] =?UTF-8?q?=E2=9C=A8=20Generate=20service=20dynamica?= =?UTF-8?q?lly?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app.go | 15 +++++++++++---- cmd/lenore/main.go | 25 +++++-------------------- config/version.go | 10 ++++++++++ 3 files changed, 26 insertions(+), 24 deletions(-) create mode 100644 config/version.go diff --git a/app.go b/app.go index 6390de9..8cb5604 100644 --- a/app.go +++ b/app.go @@ -3,6 +3,7 @@ package lenore import ( "errors" "fmt" + "time" "codeberg.org/danjones000/lenore/config" "codeberg.org/danjones000/lenore/store" @@ -11,6 +12,10 @@ import ( boxap "github.com/go-ap/fedbox/activitypub" ) +func init() { + client.UserAgent = config.UserAgent +} + type App struct { conf config.Config self vocab.Service @@ -30,10 +35,12 @@ func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { } selfIRI := boxap.DefaultServiceIRI(conf.BaseURL) - self, err := boxap.LoadActor(db, selfIRI) - if err != nil { - return nil, err - } + self := boxap.Self(selfIRI) + self.Name = vocab.DefaultNaturalLanguageValue(app.Name()) + self.AttributedTo = vocab.IRI(config.DevUrl) + self.Summary = vocab.DefaultNaturalLanguageValue("ActivityPub-powered reader") + self.Published = time.Now() + self.Updated = time.Now() app.self = self app.client = *client.New() diff --git a/cmd/lenore/main.go b/cmd/lenore/main.go index f879352..0f7d6be 100644 --- a/cmd/lenore/main.go +++ b/cmd/lenore/main.go @@ -4,44 +4,29 @@ package main import ( "fmt" - "time" "codeberg.org/danjones000/lenore" "codeberg.org/danjones000/lenore/config" - vocab "github.com/go-ap/activitypub" - boxap "github.com/go-ap/fedbox/activitypub" "github.com/go-ap/storage-sqlite" ) func main() { conf := config.Config{BaseURL: "http://localhost:4523/"} - sqlConf := sqlite.Config{Path: "storage"} - err := sqlite.Bootstrap(sqlConf) - if err != nil { - panic(err) - } db, err := sqlite.New(sqlConf) if err != nil { panic(err) } - serv := vocab.ServiceNew(boxap.DefaultServiceIRI(conf.BaseURL)) - serv.Name = vocab.DefaultNaturalLanguageValue("Lenore") - serv.Summary = vocab.DefaultNaturalLanguageValue("ActivityPub-powered reader") - serv.Published = time.Now() - serv.Updated = time.Now() - _, err = db.Save(serv) - if err != nil { - panic(err) - } - - app, err := lenore.NewApp("0.0.0", conf, db) + app, err := lenore.NewApp(config.Version, conf, db) if err != nil { panic(err) } fmt.Println(app) - fmt.Println(app.Service().ID) + serv := app.Service() + out, _ := serv.MarshalJSON() + fmt.Println(string(out)) + fmt.Println(serv.ID) } diff --git a/config/version.go b/config/version.go new file mode 100644 index 0000000..3731179 --- /dev/null +++ b/config/version.go @@ -0,0 +1,10 @@ +package config + +const ( + AppName string = "lenore" + Version string = "0.0.1" + Url string = "https://codeberg.org/danjones000/lenore" + DevUrl string = "https://codeberg.org/danjones000" + Email string = "danjones@goodevilgenius.org" + UserAgent string = AppName + "/" + Version + " (" + Url + "; " + Email + ")" +) From d6546e5ff979c56de3af36e8b55f0015528ccf82 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 17:34:47 -0500 Subject: [PATCH 09/22] =?UTF-8?q?=F0=9F=9B=A0=20Add=20static=20analysis?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 35 +++++++++++++++++++++++++++++------ app.go | 2 +- app_test.go | 2 +- 3 files changed, 31 insertions(+), 8 deletions(-) diff --git a/Taskfile.yml b/Taskfile.yml index eb52f83..4a5c4ce 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -7,12 +7,6 @@ tasks: - task: test - task: build - ft: - desc: Format and test - cmds: - - task: fmt - - task: test - fmt: desc: Format go code sources: @@ -20,8 +14,37 @@ tasks: cmds: - go fmt ./... + vet: + desc: Vet go code + sources: + - '**/*.go' + cmds: + - go vet ./... + + critic: + desc: Critique go code + sources: + - '**/*.go' + cmds: + - gocritic check ./... + + staticcheck: + desc: Static check go code + sources: + - '**/*.go' + cmds: + - staticcheck ./... + + analyze: + desc: Do static analysis + deps: + - vet + - critic + - staticcheck + test: desc: Run unit tests + deps: [fmt, vet] sources: - '**/*.go' generates: diff --git a/app.go b/app.go index 8cb5604..6b33a8c 100644 --- a/app.go +++ b/app.go @@ -27,7 +27,7 @@ type App struct { func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { if conf.BaseURL == "" { - return nil, errors.New("Missing BaseURL") + return nil, errors.New("missing BaseURL") } app := App{ version: ver, diff --git a/app_test.go b/app_test.go index 7bc0cac..426985e 100644 --- a/app_test.go +++ b/app_test.go @@ -14,7 +14,7 @@ func TestEmptyBaseURL(t *testing.T) { c := config.Config{} a, er := NewApp("0.0.0", c, testmocks.GetStore()) assert.Nil(t, a) - assert.EqualError(t, er, "Missing BaseURL") + assert.EqualError(t, er, "missing BaseURL") } func TestDefaultEnvironment(t *testing.T) { From c4513aa94bd20df50dfb9126957f172f5ac45d3d Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 18:12:44 -0500 Subject: [PATCH 10/22] =?UTF-8?q?=F0=9F=9B=A0=20Mod=20tidy=20after=20fmt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 1 + go.mod | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/Taskfile.yml b/Taskfile.yml index 4a5c4ce..86e777a 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -13,6 +13,7 @@ tasks: - '**/*.go' cmds: - go fmt ./... + - go mod tidy vet: desc: Vet go code diff --git a/go.mod b/go.mod index 418bc6a..2b3ca76 100644 --- a/go.mod +++ b/go.mod @@ -6,8 +6,10 @@ require ( github.com/go-ap/activitypub v0.0.0-20240910141749-b4b8c8aa484c github.com/go-ap/client v0.0.0-20240910141951-13a4f3c4fd53 github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399 + github.com/go-ap/filters v0.0.0-20240910141936-c8f68cdf2bc9 github.com/go-ap/processing v0.0.0-20240910151355-8284a5ce9c22 github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa + github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f github.com/stretchr/testify v1.9.0 ) @@ -20,7 +22,6 @@ require ( github.com/dustin/go-humanize v1.0.1 // indirect github.com/go-ap/cache v0.0.0-20240910141827-94f8ac1a9133 // indirect github.com/go-ap/errors v0.0.0-20240910140019-1e9d33cc1568 // indirect - github.com/go-ap/filters v0.0.0-20240910141936-c8f68cdf2bc9 // indirect github.com/go-ap/jsonld v0.0.0-20221030091449-f2a191312c73 // indirect github.com/go-chi/chi/v5 v5.1.0 // indirect github.com/go-fed/httpsig v1.1.0 // indirect @@ -31,7 +32,6 @@ require ( github.com/mattn/go-isatty v0.0.20 // indirect github.com/mattn/go-sqlite3 v1.14.23 // indirect github.com/ncruces/go-strftime v0.1.9 // indirect - github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f // indirect github.com/pborman/uuid v1.2.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect From e7b88bcc09ae5046378ef0341f943227488d6b01 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 20:37:51 -0500 Subject: [PATCH 11/22] =?UTF-8?q?=E2=9C=A8=20Improve=20Store?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Still need to fill out SQLite bootstrap Also setup plug-in system mechanism --- app.go | 1 + cmd/lenore/main.go | 13 ++++++---- config/config.go | 7 ++++++ imports/.gitignore | 3 +++ imports/default.go | 5 ++++ internal/testmocks/store.go | 8 +++++-- store/factory.go | 34 +++++++++++++++++++++++++++ store/factory_test.go | 47 +++++++++++++++++++++++++++++++++++++ store/sqlite/repo.go | 29 +++++++++++++++++++++++ store/store.go | 13 ++++++++++ 10 files changed, 154 insertions(+), 6 deletions(-) create mode 100644 imports/.gitignore create mode 100644 imports/default.go create mode 100644 store/factory.go create mode 100644 store/factory_test.go create mode 100644 store/sqlite/repo.go diff --git a/app.go b/app.go index 6b33a8c..9ffe16d 100644 --- a/app.go +++ b/app.go @@ -6,6 +6,7 @@ import ( "time" "codeberg.org/danjones000/lenore/config" + _ "codeberg.org/danjones000/lenore/imports" "codeberg.org/danjones000/lenore/store" vocab "github.com/go-ap/activitypub" "github.com/go-ap/client" diff --git a/cmd/lenore/main.go b/cmd/lenore/main.go index 0f7d6be..012cada 100644 --- a/cmd/lenore/main.go +++ b/cmd/lenore/main.go @@ -7,14 +7,19 @@ import ( "codeberg.org/danjones000/lenore" "codeberg.org/danjones000/lenore/config" - "github.com/go-ap/storage-sqlite" + "codeberg.org/danjones000/lenore/store" ) func main() { - conf := config.Config{BaseURL: "http://localhost:4523/"} - sqlConf := sqlite.Config{Path: "storage"} + conf := config.Config{ + BaseURL: "http://localhost:4523/", + Conn: config.ConnSettings{ + Store: "sqlite", + DSN: "storage", + }, + } - db, err := sqlite.New(sqlConf) + db, err := store.MakeStore(conf.Conn.Store, conf) if err != nil { panic(err) } diff --git a/config/config.go b/config/config.go index a0125fb..953ddce 100644 --- a/config/config.go +++ b/config/config.go @@ -4,6 +4,13 @@ type Config struct { Name string Env Env BaseURL string + Conn ConnSettings +} + +type ConnSettings struct { + Store string + DSN string + AdditionalSettings map[string]any } func (c Config) Environment() Env { diff --git a/imports/.gitignore b/imports/.gitignore new file mode 100644 index 0000000..6a51c08 --- /dev/null +++ b/imports/.gitignore @@ -0,0 +1,3 @@ +* +!default.go +!.gitignore diff --git a/imports/default.go b/imports/default.go new file mode 100644 index 0000000..a757ab4 --- /dev/null +++ b/imports/default.go @@ -0,0 +1,5 @@ +package imports + +import ( + _ "codeberg.org/danjones000/lenore/store/sqlite" +) diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go index a7ae185..d4a6e54 100644 --- a/internal/testmocks/store.go +++ b/internal/testmocks/store.go @@ -1,13 +1,17 @@ package testmocks import ( - "codeberg.org/danjones000/lenore/store" + "codeberg.org/danjones000/lenore/config" vocab "github.com/go-ap/activitypub" "github.com/go-ap/filters" ) type st struct{} +func (s *st) Bootstrap(config.Config) error { + return nil +} + func (s *st) Load(iri vocab.IRI, filters ...filters.Check) (vocab.Item, error) { i := vocab.ActorNew(iri, vocab.ActorType) return i, nil @@ -36,6 +40,6 @@ func (s *st) RemoveFrom(col vocab.IRI, it vocab.Item) error { func (s *st) Close() { } -func GetStore() store.Store { +func GetStore() *st { return &st{} } diff --git a/store/factory.go b/store/factory.go new file mode 100644 index 0000000..fbcc5c0 --- /dev/null +++ b/store/factory.go @@ -0,0 +1,34 @@ +package store + +import ( + "errors" + "fmt" + + "codeberg.org/danjones000/lenore/config" +) + +var ErrNoFactory = errors.New("unknown factory") + +type StoreFactory func(config.Config) (Store, error) + +var factories map[string]StoreFactory + +func init() { + factories = make(map[string]StoreFactory) +} + +func AddFactory(name string, f StoreFactory) { + factories[name] = f +} + +func GetFactory(name string) StoreFactory { + return factories[name] +} + +func MakeStore(name string, conf config.Config) (Store, error) { + f, ok := factories[name] + if !ok { + return nil, fmt.Errorf("%w: %s", ErrNoFactory, name) + } + return f(conf) +} diff --git a/store/factory_test.go b/store/factory_test.go new file mode 100644 index 0000000..38568ac --- /dev/null +++ b/store/factory_test.go @@ -0,0 +1,47 @@ +package store + +import ( + "testing" + + "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/lenore/internal/testmocks" + "github.com/stretchr/testify/assert" +) + +var f StoreFactory = func(config.Config) (Store, error) { + return testmocks.GetStore(), nil +} + +func TestAddFactory(t *testing.T) { + AddFactory("mock", f) + defer delete(factories, "mock") + _, ok := factories["mock"] + assert.True(t, ok) +} + +func TestGetFactoryNil(t *testing.T) { + f := GetFactory("mock") + assert.Nil(t, f) +} + +func TestGetFactoryNotNil(t *testing.T) { + AddFactory("mock", f) + defer delete(factories, "mock") + f := GetFactory("mock") + assert.NotNil(t, f) +} + +func TestMakeStoreError(t *testing.T) { + s, e := MakeStore("mock", config.Config{}) + assert.Nil(t, s) + assert.ErrorIs(t, e, ErrNoFactory) + assert.ErrorContains(t, e, ErrNoFactory.Error()+": mock") +} + +func TestMakeStoreNoError(t *testing.T) { + AddFactory("mock", f) + defer delete(factories, "mock") + s, e := MakeStore("mock", config.Config{}) + assert.NotNil(t, s) + assert.NoError(t, e) +} diff --git a/store/sqlite/repo.go b/store/sqlite/repo.go new file mode 100644 index 0000000..87a43e3 --- /dev/null +++ b/store/sqlite/repo.go @@ -0,0 +1,29 @@ +package sqlite + +import ( + "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/lenore/store" + "github.com/go-ap/storage-sqlite" +) + +func init() { + store.AddFactory("sqlite", MakeStore) +} + +func MakeStore(conf config.Config) (store.Store, error) { + sqlConf := sqlite.Config{Path: conf.Conn.DSN} + db, err := sqlite.New(sqlConf) + if err != nil { + return nil, err + } + return Repo{db}, nil +} + +type Repo struct { + store.PartStore +} + +func (r Repo) Bootstrap(config.Config) error { + // @todo + return nil +} diff --git a/store/store.go b/store/store.go index 6b5336b..de38416 100644 --- a/store/store.go +++ b/store/store.go @@ -1,6 +1,7 @@ package store import ( + "codeberg.org/danjones000/lenore/config" st "github.com/go-ap/fedbox/storage" proc "github.com/go-ap/processing" "github.com/openshift/osin" @@ -21,7 +22,19 @@ type ClientLister interface { GetClient(id string) (osin.Client, error) } +type Bootstrapper interface { + // Bootstrap should initialize the data store so that it can be used. + // This will be called every time the application starts, so it MUST be idempotent and doesn't delete existing data. + // An option is to run migrations in this method. + Bootstrap(config.Config) error +} + type Store interface { + Bootstrapper + PartStore +} + +type PartStore interface { ClientSaver ClientLister proc.Store From 9ddaa98ff4dc5d51b82d27278cf7204f69f399d4 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 23:07:28 -0500 Subject: [PATCH 12/22] =?UTF-8?q?=E2=9C=A8=20Load=20config=20from=20TOML?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/config.go | 14 +++++++------- config/load.go | 8 ++++++++ config/load_test.go | 29 +++++++++++++++++++++++++++++ go.mod | 1 + go.sum | 2 ++ 5 files changed, 47 insertions(+), 7 deletions(-) create mode 100644 config/load.go create mode 100644 config/load_test.go diff --git a/config/config.go b/config/config.go index 953ddce..27102a8 100644 --- a/config/config.go +++ b/config/config.go @@ -1,16 +1,16 @@ package config type Config struct { - Name string - Env Env - BaseURL string - Conn ConnSettings + Name string `toml:"name"` + Env Env `toml:"env"` + BaseURL string `toml:"base_url"` + Conn ConnSettings `toml:"conn"` } type ConnSettings struct { - Store string - DSN string - AdditionalSettings map[string]any + Store string `toml:"store"` + DSN string `toml:"dsn"` + Settings map[string]any `toml:"settings"` } func (c Config) Environment() Env { diff --git a/config/load.go b/config/load.go new file mode 100644 index 0000000..3293b65 --- /dev/null +++ b/config/load.go @@ -0,0 +1,8 @@ +package config + +import "github.com/BurntSushi/toml" + +func LoadFromToml(path string) (c Config, err error) { + _, err = toml.DecodeFile(path, &c) + return +} diff --git a/config/load_test.go b/config/load_test.go new file mode 100644 index 0000000..b289496 --- /dev/null +++ b/config/load_test.go @@ -0,0 +1,29 @@ +package config + +import ( + "fmt" + "os" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestLoadTomlMissing(t *testing.T) { + _, e := LoadFromToml("not-a-real-filee") + assert.Error(t, e) +} + +func TestLoadTomlGood(t *testing.T) { + tmp, _ := os.CreateTemp("", "*.toml") + defer tmp.Close() + fmt.Fprintln(tmp, `name = "Cool"`) + fmt.Fprintln(tmp, "[conn]") + fmt.Fprintln(tmp, `store = "sqlite"`) + fmt.Fprintln(tmp, "[conn.settings]") + fmt.Fprintln(tmp, `num = 42`) + c, e := LoadFromToml(tmp.Name()) + assert.NoError(t, e) + assert.Equal(t, "Cool", c.Name) + assert.Equal(t, "sqlite", c.Conn.Store) + assert.Equal(t, int64(42), c.Conn.Settings["num"]) +} diff --git a/go.mod b/go.mod index 2b3ca76..2226a1c 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module codeberg.org/danjones000/lenore go 1.23.1 require ( + github.com/BurntSushi/toml v1.4.0 github.com/go-ap/activitypub v0.0.0-20240910141749-b4b8c8aa484c github.com/go-ap/client v0.0.0-20240910141951-13a4f3c4fd53 github.com/go-ap/fedbox v0.0.0-20240910163620-7bcedb2eb399 diff --git a/go.sum b/go.sum index 617a50d..4a5a48b 100644 --- a/go.sum +++ b/go.sum @@ -7,6 +7,8 @@ git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120 h1:OLxL9lel79BV3EHu/AM git.sr.ht/~mariusor/lw v0.0.0-20240906100438-00d2184b2120/go.mod h1:kXJ4JsgGBu7IVBKlrVvGjSLJmpsAGqZwq/JU/kTUaLw= git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7 h1:bCGvett+MiEDc5L+T9jByp671KnKRG/iJCCm0fc+21s= git.sr.ht/~mariusor/ssm v0.0.0-20240811085540-34f24cac52b7/go.mod h1:VApG24PG5Ij+tw5zpN5O61FSQU9gJK/cYQwFYM+kkwA= +github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0= +github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/carlmjohnson/be v0.23.2 h1:1QjPnPJhwGUjsD9+7h98EQlKsxnG5TV+nnEvk0wnkls= github.com/carlmjohnson/be v0.23.2/go.mod h1:KAgPUh0HpzWYZZI+IABdo80wTgY43YhbdsiLYAaSI/Q= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= From b8fc87385065f3a625853130ac2cfab243c91c30 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sat, 14 Sep 2024 23:58:05 -0500 Subject: [PATCH 13/22] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Refactor=20main=20to?= =?UTF-8?q?=20load=20toml?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Temporary until we set up actually loading from a specific file --- cmd/lenore/main.go | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-) diff --git a/cmd/lenore/main.go b/cmd/lenore/main.go index 012cada..edc4dc8 100644 --- a/cmd/lenore/main.go +++ b/cmd/lenore/main.go @@ -4,6 +4,7 @@ package main import ( "fmt" + "os" "codeberg.org/danjones000/lenore" "codeberg.org/danjones000/lenore/config" @@ -11,23 +12,15 @@ import ( ) func main() { - conf := config.Config{ - BaseURL: "http://localhost:4523/", - Conn: config.ConnSettings{ - Store: "sqlite", - DSN: "storage", - }, - } + conf, err := config.LoadFromToml(getTomlFile()) + quitErr(err) + fmt.Printf("%+v\n", conf) db, err := store.MakeStore(conf.Conn.Store, conf) - if err != nil { - panic(err) - } + quitErr(err) app, err := lenore.NewApp(config.Version, conf, db) - if err != nil { - panic(err) - } + quitErr(err) fmt.Println(app) serv := app.Service() @@ -35,3 +28,28 @@ func main() { fmt.Println(string(out)) fmt.Println(serv.ID) } +func quitErr(err error) { + if err != nil { + panic(err) + } +} + +func getTomlFile() string { + tmp, err := os.CreateTemp("", "*.toml") + if err != nil { + panic(err) + } + defer tmp.Close() + + p := tmp.Name() + fmt.Fprintln(tmp, confStr) + return p +} + +var confStr = ` +base_url = "http://localhost:4523/" + +[conn] +store = "sqlite" +dsn = "store" +` From 25ed67b2e938525a850982d33acdbaec097de04d Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sun, 15 Sep 2024 12:02:22 -0500 Subject: [PATCH 14/22] =?UTF-8?q?=F0=9F=94=A5=20Delete=20temp=20files=20in?= =?UTF-8?q?=20testing=20code?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cmd/lenore/main.go | 9 +++++---- config/load_test.go | 1 + 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/cmd/lenore/main.go b/cmd/lenore/main.go index edc4dc8..052d36d 100644 --- a/cmd/lenore/main.go +++ b/cmd/lenore/main.go @@ -12,7 +12,9 @@ import ( ) func main() { - conf, err := config.LoadFromToml(getTomlFile()) + f := getTomlFile() + defer os.Remove(f) + conf, err := config.LoadFromToml(f) quitErr(err) fmt.Printf("%+v\n", conf) @@ -28,6 +30,7 @@ func main() { fmt.Println(string(out)) fmt.Println(serv.ID) } + func quitErr(err error) { if err != nil { panic(err) @@ -36,9 +39,7 @@ func quitErr(err error) { func getTomlFile() string { tmp, err := os.CreateTemp("", "*.toml") - if err != nil { - panic(err) - } + quitErr(err) defer tmp.Close() p := tmp.Name() diff --git a/config/load_test.go b/config/load_test.go index b289496..c532392 100644 --- a/config/load_test.go +++ b/config/load_test.go @@ -15,6 +15,7 @@ func TestLoadTomlMissing(t *testing.T) { func TestLoadTomlGood(t *testing.T) { tmp, _ := os.CreateTemp("", "*.toml") + defer os.Remove(tmp.Name()) defer tmp.Close() fmt.Fprintln(tmp, `name = "Cool"`) fmt.Fprintln(tmp, "[conn]") From c703a26c10b3954c7d22b141ad09e231be67b883 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sun, 15 Sep 2024 12:37:42 -0500 Subject: [PATCH 15/22] =?UTF-8?q?=E2=9C=A8=20Load=20store=20from=20config?= =?UTF-8?q?=20name?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- store/factory.go | 4 ++++ store/factory_test.go | 10 ++++++++++ 2 files changed, 14 insertions(+) diff --git a/store/factory.go b/store/factory.go index fbcc5c0..c6c5aa8 100644 --- a/store/factory.go +++ b/store/factory.go @@ -26,6 +26,10 @@ func GetFactory(name string) StoreFactory { } func MakeStore(name string, conf config.Config) (Store, error) { + if name == "" { + name = conf.Conn.Store + } + f, ok := factories[name] if !ok { return nil, fmt.Errorf("%w: %s", ErrNoFactory, name) diff --git a/store/factory_test.go b/store/factory_test.go index 38568ac..9cde562 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -45,3 +45,13 @@ func TestMakeStoreNoError(t *testing.T) { assert.NotNil(t, s) assert.NoError(t, e) } + +func TestMakeStoreNoName(t *testing.T) { + AddFactory("mock", f) + defer delete(factories, "mock") + s, e := MakeStore("", config.Config{ + Conn: config.ConnSettings{Store: "mock"}, + }) + assert.NotNil(t, s) + assert.NoError(t, e) +} From 8a069859ea51b74825232dede293834418f2f527 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Mon, 28 Oct 2024 11:50:18 -0500 Subject: [PATCH 16/22] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Rename=20constancts?= =?UTF-8?q?=20to=20not=20be=20uppercase?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app_test.go | 12 ++++++------ config/config_test.go | 4 ++-- config/env.go | 18 +++++++++--------- config/env_test.go | 22 +++++++++++----------- 4 files changed, 28 insertions(+), 28 deletions(-) diff --git a/app_test.go b/app_test.go index 426985e..3475516 100644 --- a/app_test.go +++ b/app_test.go @@ -22,7 +22,7 @@ func TestDefaultEnvironment(t *testing.T) { a, er := NewApp("0.0.0", c, testmocks.GetStore()) assert.NoError(t, er) if assert.NotNil(t, a) { - assert.Equal(t, config.DEV, a.Environment()) + assert.Equal(t, config.Dev, a.Environment()) } } @@ -31,11 +31,11 @@ func TestGivenEnvironment(t *testing.T) { given config.Env exp config.Env }{ - {config.DEV, config.DEV}, - {config.PROD, config.PROD}, - {config.QA, config.QA}, - {config.Env("foo"), config.DEV}, - {config.Env("✨"), config.DEV}, + {config.Dev, config.Dev}, + {config.Prod, config.Prod}, + {config.Qa, config.Qa}, + {config.Env("foo"), config.Dev}, + {config.Env("✨"), config.Dev}, } for _, c := range cases { diff --git a/config/config_test.go b/config/config_test.go index 2586018..12c0e4c 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -8,12 +8,12 @@ import ( func TestEnvDefaultsToDev(t *testing.T) { c := Config{} - assert.Equal(t, DEV, c.Environment()) + assert.Equal(t, Dev, c.Environment()) } func TestInvalidEnvReturnsDev(t *testing.T) { c := Config{Env: Env("foobar")} - assert.Equal(t, DEV, c.Environment()) + assert.Equal(t, Dev, c.Environment()) } func TestValidEnvReturnsCorrect(t *testing.T) { diff --git a/config/env.go b/config/env.go index 99f8aa0..b38e4fd 100644 --- a/config/env.go +++ b/config/env.go @@ -3,24 +3,24 @@ package config type Env string const ( - DEV Env = "dev" - PROD Env = "prod" - QA Env = "qa" - TEST Env = "test" + Dev Env = "dev" + Prod Env = "prod" + Qa Env = "qa" + Test Env = "test" ) var Envs = [...]Env{ - DEV, - PROD, - QA, - TEST, + Dev, + Prod, + Qa, + Test, } func ValidEnvOrDev(e Env) Env { if ValidEnv(e) { return e } - return DEV + return Dev } func ValidEnv(env Env) bool { diff --git a/config/env_test.go b/config/env_test.go index 2084c0a..680a79b 100644 --- a/config/env_test.go +++ b/config/env_test.go @@ -21,10 +21,10 @@ func TestValidEnv(t *testing.T) { e Env exp bool }{ - {DEV, true}, - {PROD, true}, - {QA, true}, - {TEST, true}, + {Dev, true}, + {Prod, true}, + {Qa, true}, + {Test, true}, {Env("foobar"), false}, {Env(""), false}, {Env("✨"), false}, @@ -42,13 +42,13 @@ func TestValidEnvOrDev(t *testing.T) { give Env exp Env }{ - {DEV, DEV}, - {PROD, PROD}, - {QA, QA}, - {TEST, TEST}, - {Env("foobar"), DEV}, - {Env(""), DEV}, - {Env("✨"), DEV}, + {Dev, Dev}, + {Prod, Prod}, + {Qa, Qa}, + {Test, Test}, + {Env("foobar"), Dev}, + {Env(""), Dev}, + {Env("✨"), Dev}, } for _, c := range cases { From c73dfc0d3af4ed74c0042e5621f8091e2174c420 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Mon, 28 Oct 2024 13:48:22 -0500 Subject: [PATCH 17/22] =?UTF-8?q?=F0=9F=9A=9A=20Rename=20project?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 4 ++-- app.go | 8 ++++---- app_test.go | 6 +++--- cmd/{lenore => combluotion}/main.go | 8 ++++---- config/version.go | 4 ++-- go.mod | 2 +- imports/default.go | 2 +- internal/testmocks/store.go | 2 +- store/factory.go | 2 +- store/factory_test.go | 4 ++-- store/sqlite/repo.go | 4 ++-- store/store.go | 2 +- 12 files changed, 24 insertions(+), 24 deletions(-) rename cmd/{lenore => combluotion}/main.go (78%) diff --git a/Taskfile.yml b/Taskfile.yml index 86e777a..4d15ae8 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -75,6 +75,6 @@ tasks: sources: - '**/*.go' generates: - - build/lenore + - build/combluotion cmds: - - go build -o build/lenore cmd/lenore/main.go + - go build -o build/combluotion cmd/combluotion/main.go diff --git a/app.go b/app.go index 9ffe16d..514df57 100644 --- a/app.go +++ b/app.go @@ -1,13 +1,13 @@ -package lenore +package combluotion import ( "errors" "fmt" "time" - "codeberg.org/danjones000/lenore/config" - _ "codeberg.org/danjones000/lenore/imports" - "codeberg.org/danjones000/lenore/store" + "codeberg.org/danjones000/combluotion/config" + _ "codeberg.org/danjones000/combluotion/imports" + "codeberg.org/danjones000/combluotion/store" vocab "github.com/go-ap/activitypub" "github.com/go-ap/client" boxap "github.com/go-ap/fedbox/activitypub" diff --git a/app_test.go b/app_test.go index 3475516..e850b11 100644 --- a/app_test.go +++ b/app_test.go @@ -1,11 +1,11 @@ -package lenore +package combluotion import ( "fmt" "testing" - "codeberg.org/danjones000/lenore/config" - "codeberg.org/danjones000/lenore/internal/testmocks" + "codeberg.org/danjones000/combluotion/config" + "codeberg.org/danjones000/combluotion/internal/testmocks" vocab "github.com/go-ap/activitypub" "github.com/stretchr/testify/assert" ) diff --git a/cmd/lenore/main.go b/cmd/combluotion/main.go similarity index 78% rename from cmd/lenore/main.go rename to cmd/combluotion/main.go index 052d36d..0b6b769 100644 --- a/cmd/lenore/main.go +++ b/cmd/combluotion/main.go @@ -6,9 +6,9 @@ import ( "fmt" "os" - "codeberg.org/danjones000/lenore" - "codeberg.org/danjones000/lenore/config" - "codeberg.org/danjones000/lenore/store" + "codeberg.org/danjones000/combluotion" + "codeberg.org/danjones000/combluotion/config" + "codeberg.org/danjones000/combluotion/store" ) func main() { @@ -21,7 +21,7 @@ func main() { db, err := store.MakeStore(conf.Conn.Store, conf) quitErr(err) - app, err := lenore.NewApp(config.Version, conf, db) + app, err := combluotion.NewApp(config.Version, conf, db) quitErr(err) fmt.Println(app) diff --git a/config/version.go b/config/version.go index 3731179..3b5ef9d 100644 --- a/config/version.go +++ b/config/version.go @@ -1,9 +1,9 @@ package config const ( - AppName string = "lenore" + AppName string = "combluotion" Version string = "0.0.1" - Url string = "https://codeberg.org/danjones000/lenore" + Url string = "https://codeberg.org/danjones000/combluotion" DevUrl string = "https://codeberg.org/danjones000" Email string = "danjones@goodevilgenius.org" UserAgent string = AppName + "/" + Version + " (" + Url + "; " + Email + ")" diff --git a/go.mod b/go.mod index 2226a1c..b5296f3 100644 --- a/go.mod +++ b/go.mod @@ -1,4 +1,4 @@ -module codeberg.org/danjones000/lenore +module codeberg.org/danjones000/combluotion go 1.23.1 diff --git a/imports/default.go b/imports/default.go index a757ab4..c06d2b1 100644 --- a/imports/default.go +++ b/imports/default.go @@ -1,5 +1,5 @@ package imports import ( - _ "codeberg.org/danjones000/lenore/store/sqlite" + _ "codeberg.org/danjones000/combluotion/store/sqlite" ) diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go index d4a6e54..ae408d9 100644 --- a/internal/testmocks/store.go +++ b/internal/testmocks/store.go @@ -1,7 +1,7 @@ package testmocks import ( - "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/combluotion/config" vocab "github.com/go-ap/activitypub" "github.com/go-ap/filters" ) diff --git a/store/factory.go b/store/factory.go index c6c5aa8..4d19fc4 100644 --- a/store/factory.go +++ b/store/factory.go @@ -4,7 +4,7 @@ import ( "errors" "fmt" - "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/combluotion/config" ) var ErrNoFactory = errors.New("unknown factory") diff --git a/store/factory_test.go b/store/factory_test.go index 9cde562..5af7acf 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -3,8 +3,8 @@ package store import ( "testing" - "codeberg.org/danjones000/lenore/config" - "codeberg.org/danjones000/lenore/internal/testmocks" + "codeberg.org/danjones000/combluotion/config" + "codeberg.org/danjones000/combluotion/internal/testmocks" "github.com/stretchr/testify/assert" ) diff --git a/store/sqlite/repo.go b/store/sqlite/repo.go index 87a43e3..c0e780e 100644 --- a/store/sqlite/repo.go +++ b/store/sqlite/repo.go @@ -1,8 +1,8 @@ package sqlite import ( - "codeberg.org/danjones000/lenore/config" - "codeberg.org/danjones000/lenore/store" + "codeberg.org/danjones000/combluotion/config" + "codeberg.org/danjones000/combluotion/store" "github.com/go-ap/storage-sqlite" ) diff --git a/store/store.go b/store/store.go index de38416..e66fa9b 100644 --- a/store/store.go +++ b/store/store.go @@ -1,7 +1,7 @@ package store import ( - "codeberg.org/danjones000/lenore/config" + "codeberg.org/danjones000/combluotion/config" st "github.com/go-ap/fedbox/storage" proc "github.com/go-ap/processing" "github.com/openshift/osin" From ecae0d5f832e1f72145e0666f8dde97f2f2f386d Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Fri, 24 Jan 2025 16:27:05 -0600 Subject: [PATCH 18/22] =?UTF-8?q?=F0=9F=A4=A1=20Use=20uber=20mock=20for=20?= =?UTF-8?q?mocks?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 7 + app_test.go | 26 +- go.mod | 1 + go.sum | 2 + internal/testmocks/store.go | 45 - internal/testmocks/store/store_mock.go | 2260 +++++++++++++++++++++++ internal/testmocks/store_meta.go | 20 - internal/testmocks/store_osin_auth.go | 37 - internal/testmocks/store_osin_client.go | 30 - store/factory_test.go | 20 +- store/store.go | 2 + 11 files changed, 2306 insertions(+), 144 deletions(-) delete mode 100644 internal/testmocks/store.go create mode 100644 internal/testmocks/store/store_mock.go delete mode 100644 internal/testmocks/store_meta.go delete mode 100644 internal/testmocks/store_osin_auth.go delete mode 100644 internal/testmocks/store_osin_client.go diff --git a/Taskfile.yml b/Taskfile.yml index 4d15ae8..933454b 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -15,6 +15,13 @@ tasks: - go fmt ./... - go mod tidy + gen: + desc: Generate files + sources: + - '**/*.go' + cmds: + - go generate ./... + vet: desc: Vet go code sources: diff --git a/app_test.go b/app_test.go index e850b11..1182eb8 100644 --- a/app_test.go +++ b/app_test.go @@ -4,22 +4,31 @@ import ( "fmt" "testing" - "codeberg.org/danjones000/combluotion/config" - "codeberg.org/danjones000/combluotion/internal/testmocks" vocab "github.com/go-ap/activitypub" "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + + "codeberg.org/danjones000/combluotion/config" + storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) +func getStore(t *testing.T) *storeMock.MockStore { + t.Helper() + ctrl := gomock.NewController(t) + return storeMock.NewMockStore(ctrl) +} + func TestEmptyBaseURL(t *testing.T) { c := config.Config{} - a, er := NewApp("0.0.0", c, testmocks.GetStore()) + a, er := NewApp("0.0.0", c, getStore(t)) assert.Nil(t, a) assert.EqualError(t, er, "missing BaseURL") } func TestDefaultEnvironment(t *testing.T) { + store := getStore(t) c := config.Config{BaseURL: "http://localhost:1234/"} - a, er := NewApp("0.0.0", c, testmocks.GetStore()) + a, er := NewApp("0.0.0", c, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, config.Dev, a.Environment()) @@ -40,8 +49,9 @@ func TestGivenEnvironment(t *testing.T) { for _, c := range cases { t.Run(string(c.given), func(t *testing.T) { + store := getStore(t) conf := config.Config{BaseURL: "http://localhost:1234/", Env: c.given} - a, er := NewApp("0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, conf, a.Config()) @@ -52,9 +62,10 @@ func TestGivenEnvironment(t *testing.T) { } func TestService(t *testing.T) { + store := getStore(t) base := "http://localhost:1234/" conf := config.Config{BaseURL: base} - a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, vocab.IRI(base), a.ServiceIRI()) @@ -75,9 +86,10 @@ func TestStrings(t *testing.T) { for _, c := range cases { t.Run(c.given, func(t *testing.T) { + store := getStore(t) conf := config.Config{BaseURL: "http://localhost:1234/", Name: c.given} expStr := fmt.Sprintf("%s (%s)", c.exp, "0.0.0.0") - a, er := NewApp("0.0.0.0", conf, testmocks.GetStore()) + a, er := NewApp("0.0.0.0", conf, store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, c.exp, a.Name()) diff --git a/go.mod b/go.mod index b5296f3..1b02cbd 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/go-ap/storage-sqlite v0.0.0-20240910151457-20fa80d963aa github.com/openshift/osin v1.0.2-0.20220317075346-0f4d38c6e53f github.com/stretchr/testify v1.9.0 + go.uber.org/mock v0.5.0 ) require ( diff --git a/go.sum b/go.sum index 4a5a48b..b227af7 100644 --- a/go.sum +++ b/go.sum @@ -83,6 +83,8 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ= github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= +go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= diff --git a/internal/testmocks/store.go b/internal/testmocks/store.go deleted file mode 100644 index ae408d9..0000000 --- a/internal/testmocks/store.go +++ /dev/null @@ -1,45 +0,0 @@ -package testmocks - -import ( - "codeberg.org/danjones000/combluotion/config" - vocab "github.com/go-ap/activitypub" - "github.com/go-ap/filters" -) - -type st struct{} - -func (s *st) Bootstrap(config.Config) error { - return nil -} - -func (s *st) Load(iri vocab.IRI, filters ...filters.Check) (vocab.Item, error) { - i := vocab.ActorNew(iri, vocab.ActorType) - return i, nil -} - -func (s *st) Save(v vocab.Item) (vocab.Item, error) { - return v, nil -} - -func (s *st) Delete(v vocab.Item) error { - return nil -} - -func (s *st) Create(col vocab.CollectionInterface) (vocab.CollectionInterface, error) { - return col, nil -} - -func (s *st) AddTo(col vocab.IRI, it vocab.Item) error { - return nil -} - -func (s *st) RemoveFrom(col vocab.IRI, it vocab.Item) error { - return nil -} - -func (s *st) Close() { -} - -func GetStore() *st { - return &st{} -} diff --git a/internal/testmocks/store/store_mock.go b/internal/testmocks/store/store_mock.go new file mode 100644 index 0000000..336d745 --- /dev/null +++ b/internal/testmocks/store/store_mock.go @@ -0,0 +1,2260 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: store.go +// +// Generated by this command: +// +// mockgen -source store.go -destination ../internal/testmocks/store/store_mock.go -package store -typed +// + +// Package store is a generated GoMock package. +package store + +import ( + crypto "crypto" + reflect "reflect" + + config "codeberg.org/danjones000/combluotion/config" + activitypub "github.com/go-ap/activitypub" + filters "github.com/go-ap/filters" + processing "github.com/go-ap/processing" + osin "github.com/openshift/osin" + gomock "go.uber.org/mock/gomock" +) + +// MockClientSaver is a mock of ClientSaver interface. +type MockClientSaver struct { + ctrl *gomock.Controller + recorder *MockClientSaverMockRecorder + isgomock struct{} +} + +// MockClientSaverMockRecorder is the mock recorder for MockClientSaver. +type MockClientSaverMockRecorder struct { + mock *MockClientSaver +} + +// NewMockClientSaver creates a new mock instance. +func NewMockClientSaver(ctrl *gomock.Controller) *MockClientSaver { + mock := &MockClientSaver{ctrl: ctrl} + mock.recorder = &MockClientSaverMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClientSaver) EXPECT() *MockClientSaverMockRecorder { + return m.recorder +} + +// CreateClient mocks base method. +func (m *MockClientSaver) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockClientSaverMockRecorder) CreateClient(c any) *MockClientSaverCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockClientSaver)(nil).CreateClient), c) + return &MockClientSaverCreateClientCall{Call: call} +} + +// MockClientSaverCreateClientCall wrap *gomock.Call +type MockClientSaverCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockClientSaverCreateClientCall) Return(arg0 error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockClientSaverCreateClientCall) Do(f func(osin.Client) error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockClientSaverCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// RemoveClient mocks base method. +func (m *MockClientSaver) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockClientSaverMockRecorder) RemoveClient(id any) *MockClientSaverRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockClientSaver)(nil).RemoveClient), id) + return &MockClientSaverRemoveClientCall{Call: call} +} + +// MockClientSaverRemoveClientCall wrap *gomock.Call +type MockClientSaverRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientSaverRemoveClientCall) Return(arg0 error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientSaverRemoveClientCall) Do(f func(string) error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientSaverRemoveClientCall) DoAndReturn(f func(string) error) *MockClientSaverRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockClientSaver) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockClientSaverMockRecorder) UpdateClient(c any) *MockClientSaverUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockClientSaver)(nil).UpdateClient), c) + return &MockClientSaverUpdateClientCall{Call: call} +} + +// MockClientSaverUpdateClientCall wrap *gomock.Call +type MockClientSaverUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockClientSaverUpdateClientCall) Return(arg0 error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockClientSaverUpdateClientCall) Do(f func(osin.Client) error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockClientSaverUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// MockClientLister is a mock of ClientLister interface. +type MockClientLister struct { + ctrl *gomock.Controller + recorder *MockClientListerMockRecorder + isgomock struct{} +} + +// MockClientListerMockRecorder is the mock recorder for MockClientLister. +type MockClientListerMockRecorder struct { + mock *MockClientLister +} + +// NewMockClientLister creates a new mock instance. +func NewMockClientLister(ctrl *gomock.Controller) *MockClientLister { + mock := &MockClientLister{ctrl: ctrl} + mock.recorder = &MockClientListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClientLister) EXPECT() *MockClientListerMockRecorder { + return m.recorder +} + +// GetClient mocks base method. +func (m *MockClientLister) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockClientListerMockRecorder) GetClient(id any) *MockClientListerGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientLister)(nil).GetClient), id) + return &MockClientListerGetClientCall{Call: call} +} + +// MockClientListerGetClientCall wrap *gomock.Call +type MockClientListerGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientListerGetClientCall) Return(arg0 osin.Client, arg1 error) *MockClientListerGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientListerGetClientCall) Do(f func(string) (osin.Client, error)) *MockClientListerGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientListerGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockClientListerGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockClientLister) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockClientListerMockRecorder) ListClients() *MockClientListerListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockClientLister)(nil).ListClients)) + return &MockClientListerListClientsCall{Call: call} +} + +// MockClientListerListClientsCall wrap *gomock.Call +type MockClientListerListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientListerListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockClientListerListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientListerListClientsCall) Do(f func() ([]osin.Client, error)) *MockClientListerListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientListerListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockClientListerListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockBootstrapper is a mock of Bootstrapper interface. +type MockBootstrapper struct { + ctrl *gomock.Controller + recorder *MockBootstrapperMockRecorder + isgomock struct{} +} + +// MockBootstrapperMockRecorder is the mock recorder for MockBootstrapper. +type MockBootstrapperMockRecorder struct { + mock *MockBootstrapper +} + +// NewMockBootstrapper creates a new mock instance. +func NewMockBootstrapper(ctrl *gomock.Controller) *MockBootstrapper { + mock := &MockBootstrapper{ctrl: ctrl} + mock.recorder = &MockBootstrapperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBootstrapper) EXPECT() *MockBootstrapperMockRecorder { + return m.recorder +} + +// Bootstrap mocks base method. +func (m *MockBootstrapper) Bootstrap(arg0 config.Config) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrap", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Bootstrap indicates an expected call of Bootstrap. +func (mr *MockBootstrapperMockRecorder) Bootstrap(arg0 any) *MockBootstrapperBootstrapCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockBootstrapper)(nil).Bootstrap), arg0) + return &MockBootstrapperBootstrapCall{Call: call} +} + +// MockBootstrapperBootstrapCall wrap *gomock.Call +type MockBootstrapperBootstrapCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBootstrapperBootstrapCall) Return(arg0 error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBootstrapperBootstrapCall) Do(f func(config.Config) error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBootstrapperBootstrapCall) DoAndReturn(f func(config.Config) error) *MockBootstrapperBootstrapCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockStore is a mock of Store interface. +type MockStore struct { + ctrl *gomock.Controller + recorder *MockStoreMockRecorder + isgomock struct{} +} + +// MockStoreMockRecorder is the mock recorder for MockStore. +type MockStoreMockRecorder struct { + mock *MockStore +} + +// NewMockStore creates a new mock instance. +func NewMockStore(ctrl *gomock.Controller) *MockStore { + mock := &MockStore{ctrl: ctrl} + mock.recorder = &MockStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStore) EXPECT() *MockStoreMockRecorder { + return m.recorder +} + +// AddTo mocks base method. +func (m *MockStore) AddTo(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTo", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddTo indicates an expected call of AddTo. +func (mr *MockStoreMockRecorder) AddTo(col, it any) *MockStoreAddToCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockStore)(nil).AddTo), col, it) + return &MockStoreAddToCall{Call: call} +} + +// MockStoreAddToCall wrap *gomock.Call +type MockStoreAddToCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreAddToCall) Return(arg0 error) *MockStoreAddToCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Bootstrap mocks base method. +func (m *MockStore) Bootstrap(arg0 config.Config) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bootstrap", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Bootstrap indicates an expected call of Bootstrap. +func (mr *MockStoreMockRecorder) Bootstrap(arg0 any) *MockStoreBootstrapCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockStore)(nil).Bootstrap), arg0) + return &MockStoreBootstrapCall{Call: call} +} + +// MockStoreBootstrapCall wrap *gomock.Call +type MockStoreBootstrapCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreBootstrapCall) Return(arg0 error) *MockStoreBootstrapCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreBootstrapCall) Do(f func(config.Config) error) *MockStoreBootstrapCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreBootstrapCall) DoAndReturn(f func(config.Config) error) *MockStoreBootstrapCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Clone mocks base method. +func (m *MockStore) Clone() osin.Storage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clone") + ret0, _ := ret[0].(osin.Storage) + return ret0 +} + +// Clone indicates an expected call of Clone. +func (mr *MockStoreMockRecorder) Clone() *MockStoreCloneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockStore)(nil).Clone)) + return &MockStoreCloneCall{Call: call} +} + +// MockStoreCloneCall wrap *gomock.Call +type MockStoreCloneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCloneCall) Return(arg0 osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCloneCall) Do(f func() osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockStoreCloneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Close mocks base method. +func (m *MockStore) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockStoreMockRecorder) Close() *MockStoreCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close)) + return &MockStoreCloseCall{Call: call} +} + +// MockStoreCloseCall wrap *gomock.Call +type MockStoreCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCloseCall) Return() *MockStoreCloseCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCloseCall) Do(f func()) *MockStoreCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCloseCall) DoAndReturn(f func()) *MockStoreCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", col) + ret0, _ := ret[0].(activitypub.CollectionInterface) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockStoreMockRecorder) Create(col any) *MockStoreCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStore)(nil).Create), col) + return &MockStoreCreateCall{Call: call} +} + +// MockStoreCreateCall wrap *gomock.Call +type MockStoreCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockStoreCreateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreateClient mocks base method. +func (m *MockStore) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockStoreMockRecorder) CreateClient(c any) *MockStoreCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockStore)(nil).CreateClient), c) + return &MockStoreCreateClientCall{Call: call} +} + +// MockStoreCreateClientCall wrap *gomock.Call +type MockStoreCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockStoreCreateClientCall) Return(arg0 error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockStoreCreateClientCall) Do(f func(osin.Client) error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// Delete mocks base method. +func (m *MockStore) Delete(arg0 activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockStoreMockRecorder) Delete(arg0 any) *MockStoreDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStore)(nil).Delete), arg0) + return &MockStoreDeleteCall{Call: call} +} + +// MockStoreDeleteCall wrap *gomock.Call +type MockStoreDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreDeleteCall) Return(arg0 error) *MockStoreDeleteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreDeleteCall) Do(f func(activitypub.Item) error) *MockStoreDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockStoreDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetClient mocks base method. +func (m *MockStore) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockStoreMockRecorder) GetClient(id any) *MockStoreGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockStore)(nil).GetClient), id) + return &MockStoreGetClientCall{Call: call} +} + +// MockStoreGetClientCall wrap *gomock.Call +type MockStoreGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockStoreGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockStoreGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockStoreGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockStore) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockStoreMockRecorder) ListClients() *MockStoreListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockStore)(nil).ListClients)) + return &MockStoreListClientsCall{Call: call} +} + +// MockStoreListClientsCall wrap *gomock.Call +type MockStoreListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockStoreListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockStoreListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockStoreListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Load mocks base method. +func (m *MockStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Load", varargs...) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Load indicates an expected call of Load. +func (mr *MockStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockStoreLoadCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStore)(nil).Load), varargs...) + return &MockStoreLoadCall{Call: call} +} + +// MockStoreLoadCall wrap *gomock.Call +type MockStoreLoadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreLoadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAccess mocks base method. +func (m *MockStore) LoadAccess(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAccess", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAccess indicates an expected call of LoadAccess. +func (mr *MockStoreMockRecorder) LoadAccess(token any) *MockStoreLoadAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockStore)(nil).LoadAccess), token) + return &MockStoreLoadAccessCall{Call: call} +} + +// MockStoreLoadAccessCall wrap *gomock.Call +type MockStoreLoadAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadAccessCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAuthorize mocks base method. +func (m *MockStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAuthorize", code) + ret0, _ := ret[0].(*osin.AuthorizeData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAuthorize indicates an expected call of LoadAuthorize. +func (mr *MockStoreMockRecorder) LoadAuthorize(code any) *MockStoreLoadAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockStore)(nil).LoadAuthorize), code) + return &MockStoreLoadAuthorizeCall{Call: call} +} + +// MockStoreLoadAuthorizeCall wrap *gomock.Call +type MockStoreLoadAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadKey mocks base method. +func (m *MockStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadKey", arg0) + ret0, _ := ret[0].(crypto.PrivateKey) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadKey indicates an expected call of LoadKey. +func (mr *MockStoreMockRecorder) LoadKey(arg0 any) *MockStoreLoadKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockStore)(nil).LoadKey), arg0) + return &MockStoreLoadKeyCall{Call: call} +} + +// MockStoreLoadKeyCall wrap *gomock.Call +type MockStoreLoadKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockStoreLoadKeyCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadMetadata mocks base method. +func (m *MockStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadMetadata", arg0) + ret0, _ := ret[0].(*processing.Metadata) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadMetadata indicates an expected call of LoadMetadata. +func (mr *MockStoreMockRecorder) LoadMetadata(arg0 any) *MockStoreLoadMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockStore)(nil).LoadMetadata), arg0) + return &MockStoreLoadMetadataCall{Call: call} +} + +// MockStoreLoadMetadataCall wrap *gomock.Call +type MockStoreLoadMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockStoreLoadMetadataCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadRefresh mocks base method. +func (m *MockStore) LoadRefresh(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadRefresh", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadRefresh indicates an expected call of LoadRefresh. +func (mr *MockStoreMockRecorder) LoadRefresh(token any) *MockStoreLoadRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockStore)(nil).LoadRefresh), token) + return &MockStoreLoadRefreshCall{Call: call} +} + +// MockStoreLoadRefreshCall wrap *gomock.Call +type MockStoreLoadRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadRefreshCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAccess mocks base method. +func (m *MockStore) RemoveAccess(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAccess", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAccess indicates an expected call of RemoveAccess. +func (mr *MockStoreMockRecorder) RemoveAccess(token any) *MockStoreRemoveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockStore)(nil).RemoveAccess), token) + return &MockStoreRemoveAccessCall{Call: call} +} + +// MockStoreRemoveAccessCall wrap *gomock.Call +type MockStoreRemoveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveAccessCall) Return(arg0 error) *MockStoreRemoveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveAccessCall) Do(f func(string) error) *MockStoreRemoveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockStoreRemoveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAuthorize mocks base method. +func (m *MockStore) RemoveAuthorize(code string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAuthorize", code) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAuthorize indicates an expected call of RemoveAuthorize. +func (mr *MockStoreMockRecorder) RemoveAuthorize(code any) *MockStoreRemoveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockStore)(nil).RemoveAuthorize), code) + return &MockStoreRemoveAuthorizeCall{Call: call} +} + +// MockStoreRemoveAuthorizeCall wrap *gomock.Call +type MockStoreRemoveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveAuthorizeCall) Return(arg0 error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveAuthorizeCall) Do(f func(string) error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockStoreRemoveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveClient mocks base method. +func (m *MockStore) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockStoreMockRecorder) RemoveClient(id any) *MockStoreRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockStore)(nil).RemoveClient), id) + return &MockStoreRemoveClientCall{Call: call} +} + +// MockStoreRemoveClientCall wrap *gomock.Call +type MockStoreRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveClientCall) Return(arg0 error) *MockStoreRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveClientCall) Do(f func(string) error) *MockStoreRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockStoreRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveFrom mocks base method. +func (m *MockStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveFrom", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveFrom indicates an expected call of RemoveFrom. +func (mr *MockStoreMockRecorder) RemoveFrom(col, it any) *MockStoreRemoveFromCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockStore)(nil).RemoveFrom), col, it) + return &MockStoreRemoveFromCall{Call: call} +} + +// MockStoreRemoveFromCall wrap *gomock.Call +type MockStoreRemoveFromCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveFromCall) Return(arg0 error) *MockStoreRemoveFromCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveRefresh mocks base method. +func (m *MockStore) RemoveRefresh(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRefresh", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveRefresh indicates an expected call of RemoveRefresh. +func (mr *MockStoreMockRecorder) RemoveRefresh(token any) *MockStoreRemoveRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockStore)(nil).RemoveRefresh), token) + return &MockStoreRemoveRefreshCall{Call: call} +} + +// MockStoreRemoveRefreshCall wrap *gomock.Call +type MockStoreRemoveRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreRemoveRefreshCall) Return(arg0 error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreRemoveRefreshCall) Do(f func(string) error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockStoreRemoveRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Save mocks base method. +func (m *MockStore) Save(arg0 activitypub.Item) (activitypub.Item, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", arg0) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Save indicates an expected call of Save. +func (mr *MockStoreMockRecorder) Save(arg0 any) *MockStoreSaveCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStore)(nil).Save), arg0) + return &MockStoreSaveCall{Call: call} +} + +// MockStoreSaveCall wrap *gomock.Call +type MockStoreSaveCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreSaveCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAccess mocks base method. +func (m *MockStore) SaveAccess(arg0 *osin.AccessData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAccess", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAccess indicates an expected call of SaveAccess. +func (mr *MockStoreMockRecorder) SaveAccess(arg0 any) *MockStoreSaveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockStore)(nil).SaveAccess), arg0) + return &MockStoreSaveAccessCall{Call: call} +} + +// MockStoreSaveAccessCall wrap *gomock.Call +type MockStoreSaveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveAccessCall) Return(arg0 error) *MockStoreSaveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockStoreSaveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockStoreSaveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAuthorize mocks base method. +func (m *MockStore) SaveAuthorize(arg0 *osin.AuthorizeData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAuthorize", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAuthorize indicates an expected call of SaveAuthorize. +func (mr *MockStoreMockRecorder) SaveAuthorize(arg0 any) *MockStoreSaveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockStore)(nil).SaveAuthorize), arg0) + return &MockStoreSaveAuthorizeCall{Call: call} +} + +// MockStoreSaveAuthorizeCall wrap *gomock.Call +type MockStoreSaveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveAuthorizeCall) Return(arg0 error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveMetadata mocks base method. +func (m *MockStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveMetadata indicates an expected call of SaveMetadata. +func (mr *MockStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockStoreSaveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockStore)(nil).SaveMetadata), arg0, arg1) + return &MockStoreSaveMetadataCall{Call: call} +} + +// MockStoreSaveMetadataCall wrap *gomock.Call +type MockStoreSaveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreSaveMetadataCall) Return(arg0 error) *MockStoreSaveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockStore) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockStoreMockRecorder) UpdateClient(c any) *MockStoreUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockStore)(nil).UpdateClient), c) + return &MockStoreUpdateClientCall{Call: call} +} + +// MockStoreUpdateClientCall wrap *gomock.Call +type MockStoreUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockStoreUpdateClientCall) Return(arg0 error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockStoreUpdateClientCall) Do(f func(osin.Client) error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// MockPartStore is a mock of PartStore interface. +type MockPartStore struct { + ctrl *gomock.Controller + recorder *MockPartStoreMockRecorder + isgomock struct{} +} + +// MockPartStoreMockRecorder is the mock recorder for MockPartStore. +type MockPartStoreMockRecorder struct { + mock *MockPartStore +} + +// NewMockPartStore creates a new mock instance. +func NewMockPartStore(ctrl *gomock.Controller) *MockPartStore { + mock := &MockPartStore{ctrl: ctrl} + mock.recorder = &MockPartStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPartStore) EXPECT() *MockPartStoreMockRecorder { + return m.recorder +} + +// AddTo mocks base method. +func (m *MockPartStore) AddTo(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTo", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddTo indicates an expected call of AddTo. +func (mr *MockPartStoreMockRecorder) AddTo(col, it any) *MockPartStoreAddToCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockPartStore)(nil).AddTo), col, it) + return &MockPartStoreAddToCall{Call: call} +} + +// MockPartStoreAddToCall wrap *gomock.Call +type MockPartStoreAddToCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreAddToCall) Return(arg0 error) *MockPartStoreAddToCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Clone mocks base method. +func (m *MockPartStore) Clone() osin.Storage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clone") + ret0, _ := ret[0].(osin.Storage) + return ret0 +} + +// Clone indicates an expected call of Clone. +func (mr *MockPartStoreMockRecorder) Clone() *MockPartStoreCloneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockPartStore)(nil).Clone)) + return &MockPartStoreCloneCall{Call: call} +} + +// MockPartStoreCloneCall wrap *gomock.Call +type MockPartStoreCloneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCloneCall) Return(arg0 osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCloneCall) Do(f func() osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockPartStoreCloneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Close mocks base method. +func (m *MockPartStore) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockPartStoreMockRecorder) Close() *MockPartStoreCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPartStore)(nil).Close)) + return &MockPartStoreCloseCall{Call: call} +} + +// MockPartStoreCloseCall wrap *gomock.Call +type MockPartStoreCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCloseCall) Return() *MockPartStoreCloseCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCloseCall) Do(f func()) *MockPartStoreCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCloseCall) DoAndReturn(f func()) *MockPartStoreCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Create mocks base method. +func (m *MockPartStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", col) + ret0, _ := ret[0].(activitypub.CollectionInterface) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Create indicates an expected call of Create. +func (mr *MockPartStoreMockRecorder) Create(col any) *MockPartStoreCreateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPartStore)(nil).Create), col) + return &MockPartStoreCreateCall{Call: call} +} + +// MockPartStoreCreateCall wrap *gomock.Call +type MockPartStoreCreateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockPartStoreCreateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreateClient mocks base method. +func (m *MockPartStore) CreateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateClient indicates an expected call of CreateClient. +func (mr *MockPartStoreMockRecorder) CreateClient(c any) *MockPartStoreCreateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockPartStore)(nil).CreateClient), c) + return &MockPartStoreCreateClientCall{Call: call} +} + +// MockPartStoreCreateClientCall wrap *gomock.Call +type MockPartStoreCreateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockPartStoreCreateClientCall) Return(arg0 error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockPartStoreCreateClientCall) Do(f func(osin.Client) error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockPartStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreCreateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} + +// Delete mocks base method. +func (m *MockPartStore) Delete(arg0 activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockPartStoreMockRecorder) Delete(arg0 any) *MockPartStoreDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPartStore)(nil).Delete), arg0) + return &MockPartStoreDeleteCall{Call: call} +} + +// MockPartStoreDeleteCall wrap *gomock.Call +type MockPartStoreDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreDeleteCall) Return(arg0 error) *MockPartStoreDeleteCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreDeleteCall) Do(f func(activitypub.Item) error) *MockPartStoreDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockPartStoreDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetClient mocks base method. +func (m *MockPartStore) GetClient(id string) (osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetClient indicates an expected call of GetClient. +func (mr *MockPartStoreMockRecorder) GetClient(id any) *MockPartStoreGetClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockPartStore)(nil).GetClient), id) + return &MockPartStoreGetClientCall{Call: call} +} + +// MockPartStoreGetClientCall wrap *gomock.Call +type MockPartStoreGetClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockPartStoreGetClientCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListClients mocks base method. +func (m *MockPartStore) ListClients() ([]osin.Client, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListClients") + ret0, _ := ret[0].([]osin.Client) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListClients indicates an expected call of ListClients. +func (mr *MockPartStoreMockRecorder) ListClients() *MockPartStoreListClientsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockPartStore)(nil).ListClients)) + return &MockPartStoreListClientsCall{Call: call} +} + +// MockPartStoreListClientsCall wrap *gomock.Call +type MockPartStoreListClientsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockPartStoreListClientsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Load mocks base method. +func (m *MockPartStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Load", varargs...) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Load indicates an expected call of Load. +func (mr *MockPartStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockPartStoreLoadCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockPartStore)(nil).Load), varargs...) + return &MockPartStoreLoadCall{Call: call} +} + +// MockPartStoreLoadCall wrap *gomock.Call +type MockPartStoreLoadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreLoadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAccess mocks base method. +func (m *MockPartStore) LoadAccess(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAccess", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAccess indicates an expected call of LoadAccess. +func (mr *MockPartStoreMockRecorder) LoadAccess(token any) *MockPartStoreLoadAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockPartStore)(nil).LoadAccess), token) + return &MockPartStoreLoadAccessCall{Call: call} +} + +// MockPartStoreLoadAccessCall wrap *gomock.Call +type MockPartStoreLoadAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadAccessCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadAuthorize mocks base method. +func (m *MockPartStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadAuthorize", code) + ret0, _ := ret[0].(*osin.AuthorizeData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadAuthorize indicates an expected call of LoadAuthorize. +func (mr *MockPartStoreMockRecorder) LoadAuthorize(code any) *MockPartStoreLoadAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockPartStore)(nil).LoadAuthorize), code) + return &MockPartStoreLoadAuthorizeCall{Call: call} +} + +// MockPartStoreLoadAuthorizeCall wrap *gomock.Call +type MockPartStoreLoadAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadKey mocks base method. +func (m *MockPartStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadKey", arg0) + ret0, _ := ret[0].(crypto.PrivateKey) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadKey indicates an expected call of LoadKey. +func (mr *MockPartStoreMockRecorder) LoadKey(arg0 any) *MockPartStoreLoadKeyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockPartStore)(nil).LoadKey), arg0) + return &MockPartStoreLoadKeyCall{Call: call} +} + +// MockPartStoreLoadKeyCall wrap *gomock.Call +type MockPartStoreLoadKeyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockPartStoreLoadKeyCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadMetadata mocks base method. +func (m *MockPartStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadMetadata", arg0) + ret0, _ := ret[0].(*processing.Metadata) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadMetadata indicates an expected call of LoadMetadata. +func (mr *MockPartStoreMockRecorder) LoadMetadata(arg0 any) *MockPartStoreLoadMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockPartStore)(nil).LoadMetadata), arg0) + return &MockPartStoreLoadMetadataCall{Call: call} +} + +// MockPartStoreLoadMetadataCall wrap *gomock.Call +type MockPartStoreLoadMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// LoadRefresh mocks base method. +func (m *MockPartStore) LoadRefresh(token string) (*osin.AccessData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadRefresh", token) + ret0, _ := ret[0].(*osin.AccessData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadRefresh indicates an expected call of LoadRefresh. +func (mr *MockPartStoreMockRecorder) LoadRefresh(token any) *MockPartStoreLoadRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockPartStore)(nil).LoadRefresh), token) + return &MockPartStoreLoadRefreshCall{Call: call} +} + +// MockPartStoreLoadRefreshCall wrap *gomock.Call +type MockPartStoreLoadRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAccess mocks base method. +func (m *MockPartStore) RemoveAccess(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAccess", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAccess indicates an expected call of RemoveAccess. +func (mr *MockPartStoreMockRecorder) RemoveAccess(token any) *MockPartStoreRemoveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockPartStore)(nil).RemoveAccess), token) + return &MockPartStoreRemoveAccessCall{Call: call} +} + +// MockPartStoreRemoveAccessCall wrap *gomock.Call +type MockPartStoreRemoveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveAccessCall) Return(arg0 error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveAccessCall) Do(f func(string) error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveAuthorize mocks base method. +func (m *MockPartStore) RemoveAuthorize(code string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAuthorize", code) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveAuthorize indicates an expected call of RemoveAuthorize. +func (mr *MockPartStoreMockRecorder) RemoveAuthorize(code any) *MockPartStoreRemoveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockPartStore)(nil).RemoveAuthorize), code) + return &MockPartStoreRemoveAuthorizeCall{Call: call} +} + +// MockPartStoreRemoveAuthorizeCall wrap *gomock.Call +type MockPartStoreRemoveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveAuthorizeCall) Return(arg0 error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveAuthorizeCall) Do(f func(string) error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveClient mocks base method. +func (m *MockPartStore) RemoveClient(id string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClient", id) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveClient indicates an expected call of RemoveClient. +func (mr *MockPartStoreMockRecorder) RemoveClient(id any) *MockPartStoreRemoveClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockPartStore)(nil).RemoveClient), id) + return &MockPartStoreRemoveClientCall{Call: call} +} + +// MockPartStoreRemoveClientCall wrap *gomock.Call +type MockPartStoreRemoveClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveClientCall) Return(arg0 error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveClientCall) Do(f func(string) error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveClientCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveFrom mocks base method. +func (m *MockPartStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveFrom", col, it) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveFrom indicates an expected call of RemoveFrom. +func (mr *MockPartStoreMockRecorder) RemoveFrom(col, it any) *MockPartStoreRemoveFromCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockPartStore)(nil).RemoveFrom), col, it) + return &MockPartStoreRemoveFromCall{Call: call} +} + +// MockPartStoreRemoveFromCall wrap *gomock.Call +type MockPartStoreRemoveFromCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveFromCall) Return(arg0 error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveRefresh mocks base method. +func (m *MockPartStore) RemoveRefresh(token string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRefresh", token) + ret0, _ := ret[0].(error) + return ret0 +} + +// RemoveRefresh indicates an expected call of RemoveRefresh. +func (mr *MockPartStoreMockRecorder) RemoveRefresh(token any) *MockPartStoreRemoveRefreshCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockPartStore)(nil).RemoveRefresh), token) + return &MockPartStoreRemoveRefreshCall{Call: call} +} + +// MockPartStoreRemoveRefreshCall wrap *gomock.Call +type MockPartStoreRemoveRefreshCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreRemoveRefreshCall) Return(arg0 error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreRemoveRefreshCall) Do(f func(string) error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveRefreshCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Save mocks base method. +func (m *MockPartStore) Save(arg0 activitypub.Item) (activitypub.Item, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", arg0) + ret0, _ := ret[0].(activitypub.Item) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Save indicates an expected call of Save. +func (mr *MockPartStoreMockRecorder) Save(arg0 any) *MockPartStoreSaveCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPartStore)(nil).Save), arg0) + return &MockPartStoreSaveCall{Call: call} +} + +// MockPartStoreSaveCall wrap *gomock.Call +type MockPartStoreSaveCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreSaveCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAccess mocks base method. +func (m *MockPartStore) SaveAccess(arg0 *osin.AccessData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAccess", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAccess indicates an expected call of SaveAccess. +func (mr *MockPartStoreMockRecorder) SaveAccess(arg0 any) *MockPartStoreSaveAccessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockPartStore)(nil).SaveAccess), arg0) + return &MockPartStoreSaveAccessCall{Call: call} +} + +// MockPartStoreSaveAccessCall wrap *gomock.Call +type MockPartStoreSaveAccessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveAccessCall) Return(arg0 error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveAuthorize mocks base method. +func (m *MockPartStore) SaveAuthorize(arg0 *osin.AuthorizeData) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveAuthorize", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveAuthorize indicates an expected call of SaveAuthorize. +func (mr *MockPartStoreMockRecorder) SaveAuthorize(arg0 any) *MockPartStoreSaveAuthorizeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockPartStore)(nil).SaveAuthorize), arg0) + return &MockPartStoreSaveAuthorizeCall{Call: call} +} + +// MockPartStoreSaveAuthorizeCall wrap *gomock.Call +type MockPartStoreSaveAuthorizeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveAuthorizeCall) Return(arg0 error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SaveMetadata mocks base method. +func (m *MockPartStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveMetadata indicates an expected call of SaveMetadata. +func (mr *MockPartStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockPartStoreSaveMetadataCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockPartStore)(nil).SaveMetadata), arg0, arg1) + return &MockPartStoreSaveMetadataCall{Call: call} +} + +// MockPartStoreSaveMetadataCall wrap *gomock.Call +type MockPartStoreSaveMetadataCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPartStoreSaveMetadataCall) Return(arg0 error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPartStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPartStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdateClient mocks base method. +func (m *MockPartStore) UpdateClient(c osin.Client) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateClient", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateClient indicates an expected call of UpdateClient. +func (mr *MockPartStoreMockRecorder) UpdateClient(c any) *MockPartStoreUpdateClientCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockPartStore)(nil).UpdateClient), c) + return &MockPartStoreUpdateClientCall{Call: call} +} + +// MockPartStoreUpdateClientCall wrap *gomock.Call +type MockPartStoreUpdateClientCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c_2 *MockPartStoreUpdateClientCall) Return(arg0 error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.Return(arg0) + return c_2 +} + +// Do rewrite *gomock.Call.Do +func (c_2 *MockPartStoreUpdateClientCall) Do(f func(osin.Client) error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.Do(f) + return c_2 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c_2 *MockPartStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreUpdateClientCall { + c_2.Call = c_2.Call.DoAndReturn(f) + return c_2 +} diff --git a/internal/testmocks/store_meta.go b/internal/testmocks/store_meta.go deleted file mode 100644 index 316ace0..0000000 --- a/internal/testmocks/store_meta.go +++ /dev/null @@ -1,20 +0,0 @@ -package testmocks - -import ( - "crypto" - - vocab "github.com/go-ap/activitypub" - proc "github.com/go-ap/processing" -) - -func (s *st) LoadKey(vocab.IRI) (crypto.PrivateKey, error) { - return nil, nil -} - -func (s *st) LoadMetadata(vocab.IRI) (*proc.Metadata, error) { - return nil, nil -} - -func (s *st) SaveMetadata(proc.Metadata, vocab.IRI) error { - return nil -} diff --git a/internal/testmocks/store_osin_auth.go b/internal/testmocks/store_osin_auth.go deleted file mode 100644 index a266cb1..0000000 --- a/internal/testmocks/store_osin_auth.go +++ /dev/null @@ -1,37 +0,0 @@ -package testmocks - -import ( - "github.com/openshift/osin" -) - -func (s *st) LoadAccess(string) (*osin.AccessData, error) { - return nil, nil -} - -func (s *st) SaveAccess(*osin.AccessData) error { - return nil -} - -func (s *st) RemoveAccess(string) error { - return nil -} - -func (s *st) LoadAuthorize(string) (*osin.AuthorizeData, error) { - return nil, nil -} - -func (s *st) SaveAuthorize(*osin.AuthorizeData) error { - return nil -} - -func (s *st) RemoveAuthorize(string) error { - return nil -} - -func (s *st) LoadRefresh(string) (*osin.AccessData, error) { - return nil, nil -} - -func (s *st) RemoveRefresh(string) error { - return nil -} diff --git a/internal/testmocks/store_osin_client.go b/internal/testmocks/store_osin_client.go deleted file mode 100644 index 980379d..0000000 --- a/internal/testmocks/store_osin_client.go +++ /dev/null @@ -1,30 +0,0 @@ -package testmocks - -import ( - "github.com/openshift/osin" -) - -func (s *st) Clone() osin.Storage { - n := *s - return &n -} - -func (s *st) GetClient(string) (osin.Client, error) { - return &osin.DefaultClient{}, nil -} - -func (s *st) CreateClient(osin.Client) error { - return nil -} - -func (s *st) UpdateClient(osin.Client) error { - return nil -} - -func (s *st) RemoveClient(string) error { - return nil -} - -func (s *st) ListClients() (cl []osin.Client, er error) { - return -} diff --git a/store/factory_test.go b/store/factory_test.go index 5af7acf..f4aa205 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -3,16 +3,23 @@ package store import ( "testing" - "codeberg.org/danjones000/combluotion/config" - "codeberg.org/danjones000/combluotion/internal/testmocks" "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + + "codeberg.org/danjones000/combluotion/config" + storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) -var f StoreFactory = func(config.Config) (Store, error) { - return testmocks.GetStore(), nil +func getStoreFactory(t *testing.T) (*gomock.Controller, StoreFactory) { + t.Helper() + ctrl := gomock.NewController(t) + return ctrl, func(config.Config) (Store, error) { + return storeMock.NewMockStore(ctrl), nil + } } func TestAddFactory(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") _, ok := factories["mock"] @@ -25,9 +32,10 @@ func TestGetFactoryNil(t *testing.T) { } func TestGetFactoryNotNil(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") - f := GetFactory("mock") + f = GetFactory("mock") assert.NotNil(t, f) } @@ -39,6 +47,7 @@ func TestMakeStoreError(t *testing.T) { } func TestMakeStoreNoError(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") s, e := MakeStore("mock", config.Config{}) @@ -47,6 +56,7 @@ func TestMakeStoreNoError(t *testing.T) { } func TestMakeStoreNoName(t *testing.T) { + _, f := getStoreFactory(t) AddFactory("mock", f) defer delete(factories, "mock") s, e := MakeStore("", config.Config{ diff --git a/store/store.go b/store/store.go index e66fa9b..e4868d8 100644 --- a/store/store.go +++ b/store/store.go @@ -7,6 +7,8 @@ import ( "github.com/openshift/osin" ) +//go:generate mockgen -source store.go -destination ../internal/testmocks/store/store_mock.go -package store -typed + type ClientSaver interface { // UpdateClient updates the client (identified by it's id) and replaces the values with the values of client. UpdateClient(c osin.Client) error From 6f06adc37d30b2e955b086f1c9c163402cc9e950 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Sun, 26 Jan 2025 20:07:45 -0600 Subject: [PATCH 19/22] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Refactor=20config?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make it easier to setup stores --- app.go | 10 +- app_test.go | 58 ++-- cmd/combluotion/main.go | 8 +- config/config.go | 80 ++++- config/config_test.go | 12 +- config/interface.go | 17 ++ config/load.go | 38 ++- config/load_test.go | 25 +- internal/testmocks/config/config_mock.go | 371 +++++++++++++++++++++++ store/factory.go | 11 +- store/factory_test.go | 61 ++-- store/sqlite/repo.go | 13 +- 12 files changed, 623 insertions(+), 81 deletions(-) create mode 100644 config/interface.go create mode 100644 internal/testmocks/config/config_mock.go diff --git a/app.go b/app.go index 514df57..fbe7524 100644 --- a/app.go +++ b/app.go @@ -27,7 +27,7 @@ type App struct { } func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { - if conf.BaseURL == "" { + if conf.BaseURL() == "" { return nil, errors.New("missing BaseURL") } app := App{ @@ -35,7 +35,7 @@ func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { conf: conf, } - selfIRI := boxap.DefaultServiceIRI(conf.BaseURL) + selfIRI := boxap.DefaultServiceIRI(conf.BaseURL()) self := boxap.Self(selfIRI) self.Name = vocab.DefaultNaturalLanguageValue(app.Name()) self.AttributedTo = vocab.IRI(config.DevUrl) @@ -54,7 +54,7 @@ func (l *App) Config() config.Config { } func (l *App) Environment() config.Env { - return l.conf.Environment() + return l.conf.Env() } func (l *App) Storage() store.Store { @@ -78,10 +78,10 @@ func (l *App) Version() string { } func (l *App) Name() string { - if l.conf.Name == "" { + if l.conf.Name() == "" { return "Lenore" } - return l.conf.Name + return l.conf.Name() } func (l *App) String() string { diff --git a/app_test.go b/app_test.go index 1182eb8..7819765 100644 --- a/app_test.go +++ b/app_test.go @@ -9,32 +9,33 @@ import ( "go.uber.org/mock/gomock" "codeberg.org/danjones000/combluotion/config" + confMock "codeberg.org/danjones000/combluotion/internal/testmocks/config" storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) -func getStore(t *testing.T) *storeMock.MockStore { +type appTest struct { + ctrl *gomock.Controller + store *storeMock.MockStore + conf *confMock.MockConfig +} + +func setupAppTest(t *testing.T) appTest { t.Helper() ctrl := gomock.NewController(t) - return storeMock.NewMockStore(ctrl) + return appTest{ctrl, storeMock.NewMockStore(ctrl), confMock.NewMockConfig(ctrl)} } func TestEmptyBaseURL(t *testing.T) { - c := config.Config{} - a, er := NewApp("0.0.0", c, getStore(t)) + th := setupAppTest(t) + th.conf. + EXPECT(). + BaseURL(). + Return("") + a, er := NewApp("0.0.0", th.conf, th.store) assert.Nil(t, a) assert.EqualError(t, er, "missing BaseURL") } -func TestDefaultEnvironment(t *testing.T) { - store := getStore(t) - c := config.Config{BaseURL: "http://localhost:1234/"} - a, er := NewApp("0.0.0", c, store) - assert.NoError(t, er) - if assert.NotNil(t, a) { - assert.Equal(t, config.Dev, a.Environment()) - } -} - func TestGivenEnvironment(t *testing.T) { cases := [...]struct { given config.Env @@ -43,18 +44,21 @@ func TestGivenEnvironment(t *testing.T) { {config.Dev, config.Dev}, {config.Prod, config.Prod}, {config.Qa, config.Qa}, - {config.Env("foo"), config.Dev}, - {config.Env("✨"), config.Dev}, } for _, c := range cases { t.Run(string(c.given), func(t *testing.T) { - store := getStore(t) - conf := config.Config{BaseURL: "http://localhost:1234/", Env: c.given} - a, er := NewApp("0.0.0", conf, store) + th := setupAppTest(t) + th.conf.EXPECT().BaseURL().Return("http://localhost:1234/").Times(2) + th.conf.EXPECT().Name().Return("") + th.conf. + EXPECT(). + Env(). + Return(c.given) + a, er := NewApp("0.0.0", th.conf, th.store) assert.NoError(t, er) if assert.NotNil(t, a) { - assert.Equal(t, conf, a.Config()) + assert.Equal(t, th.conf, a.Config()) assert.Equal(t, c.exp, a.Environment()) } }) @@ -62,10 +66,11 @@ func TestGivenEnvironment(t *testing.T) { } func TestService(t *testing.T) { - store := getStore(t) + th := setupAppTest(t) base := "http://localhost:1234/" - conf := config.Config{BaseURL: base} - a, er := NewApp("0.0.0.0", conf, store) + th.conf.EXPECT().BaseURL().Return(base).Times(2) + th.conf.EXPECT().Name().Return("") + a, er := NewApp("0.0.0.0", th.conf, th.store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, vocab.IRI(base), a.ServiceIRI()) @@ -86,10 +91,11 @@ func TestStrings(t *testing.T) { for _, c := range cases { t.Run(c.given, func(t *testing.T) { - store := getStore(t) - conf := config.Config{BaseURL: "http://localhost:1234/", Name: c.given} + th := setupAppTest(t) + th.conf.EXPECT().BaseURL().Return("http://localhost:1234/").AnyTimes() + th.conf.EXPECT().Name().Return(c.given).MinTimes(1) expStr := fmt.Sprintf("%s (%s)", c.exp, "0.0.0.0") - a, er := NewApp("0.0.0.0", conf, store) + a, er := NewApp("0.0.0.0", th.conf, th.store) assert.NoError(t, er) if assert.NotNil(t, a) { assert.Equal(t, c.exp, a.Name()) diff --git a/cmd/combluotion/main.go b/cmd/combluotion/main.go index 0b6b769..5557203 100644 --- a/cmd/combluotion/main.go +++ b/cmd/combluotion/main.go @@ -18,7 +18,7 @@ func main() { quitErr(err) fmt.Printf("%+v\n", conf) - db, err := store.MakeStore(conf.Conn.Store, conf) + db, err := store.MakeStore(conf.StoreName(), conf) quitErr(err) app, err := combluotion.NewApp(config.Version, conf, db) @@ -50,7 +50,9 @@ func getTomlFile() string { var confStr = ` base_url = "http://localhost:4523/" -[conn] +[stores] store = "sqlite" -dsn = "store" + +[stores.settings.sqlite] +path = "storage" ` diff --git a/config/config.go b/config/config.go index 27102a8..175a4bf 100644 --- a/config/config.go +++ b/config/config.go @@ -1,18 +1,76 @@ package config -type Config struct { - Name string `toml:"name"` - Env Env `toml:"env"` - BaseURL string `toml:"base_url"` - Conn ConnSettings `toml:"conn"` +import ( + "errors" + + "github.com/BurntSushi/toml" +) + +type config struct { + name string + env Env + baseURL string + stores stores + md toml.MetaData } -type ConnSettings struct { - Store string `toml:"store"` - DSN string `toml:"dsn"` - Settings map[string]any `toml:"settings"` +var _ Config = config{} + +func (c config) Name() string { + return c.name } -func (c Config) Environment() Env { - return ValidEnvOrDev(c.Env) +func (c config) Env() Env { + return ValidEnvOrDev(c.env) +} + +func (c config) BaseURL() string { + return c.baseURL +} + +func (c config) Store(name string) (Store, error) { + if name == "" { + name = c.stores.store + } + return c.stores.GetStore(name) +} + +func (c config) StoreName() string { + return c.stores.store +} + +type stores struct { + store string + settings map[string]toml.Primitive + conf *config +} + +var ErrMissingStore = errors.New("unknown store") + +func (ss stores) GetStore(name string) (Store, error) { + if tp, ok := ss.settings[name]; ok { + return store{name, tp, ss.conf.md}, nil + } + return nil, ErrMissingStore +} + +type store struct { + name string + settings toml.Primitive + md toml.MetaData +} + +var _ Store = store{} + +func (s store) Name() string { + return s.name +} + +func (s store) Map() (m map[string]any, err error) { + err = s.Decode(&m) + return +} + +func (s store) Decode(v any) error { + return s.md.PrimitiveDecode(s.settings, v) } diff --git a/config/config_test.go b/config/config_test.go index 12c0e4c..28dfc9f 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -7,20 +7,20 @@ import ( ) func TestEnvDefaultsToDev(t *testing.T) { - c := Config{} - assert.Equal(t, Dev, c.Environment()) + c := config{} + assert.Equal(t, Dev, c.Env()) } func TestInvalidEnvReturnsDev(t *testing.T) { - c := Config{Env: Env("foobar")} - assert.Equal(t, Dev, c.Environment()) + c := config{env: Env("foobar")} + assert.Equal(t, Dev, c.Env()) } func TestValidEnvReturnsCorrect(t *testing.T) { for _, e := range Envs { t.Run(string(e), func(t *testing.T) { - c := Config{Env: e} - assert.Equal(t, e, c.Environment()) + c := config{env: e} + assert.Equal(t, e, c.Env()) }) } } diff --git a/config/interface.go b/config/interface.go new file mode 100644 index 0000000..b8c59b0 --- /dev/null +++ b/config/interface.go @@ -0,0 +1,17 @@ +package config + +//go:generate mockgen -source interface.go -destination ../internal/testmocks/config/config_mock.go -package config -typed + +type Config interface { + Name() string + Env() Env + BaseURL() string + StoreName() string + Store(name string) (Store, error) +} + +type Store interface { + Name() string + Decode(v any) error + Map() (map[string]any, error) +} diff --git a/config/load.go b/config/load.go index 3293b65..1295a6d 100644 --- a/config/load.go +++ b/config/load.go @@ -2,7 +2,39 @@ package config import "github.com/BurntSushi/toml" -func LoadFromToml(path string) (c Config, err error) { - _, err = toml.DecodeFile(path, &c) - return +type confToml struct { + Name string + Env Env + BaseURL string `toml:"base_url"` + Stores storeSettings `toml:"stores"` +} + +type storeSettings struct { + Store string + Settings map[string]toml.Primitive +} + +func LoadFromToml(path string) (Config, error) { + var c confToml + md, err := toml.DecodeFile(path, &c) + if err != nil { + return nil, err + } + + conf := config{ + name: c.Name, + env: c.Env, + baseURL: c.BaseURL, + md: md, + } + + st := stores{ + store: c.Stores.Store, + settings: c.Stores.Settings, + conf: &conf, + } + + conf.stores = st + + return conf, nil } diff --git a/config/load_test.go b/config/load_test.go index c532392..a7f4d1a 100644 --- a/config/load_test.go +++ b/config/load_test.go @@ -13,18 +13,33 @@ func TestLoadTomlMissing(t *testing.T) { assert.Error(t, e) } +type sqlSett struct { + Path string + Num int +} + func TestLoadTomlGood(t *testing.T) { tmp, _ := os.CreateTemp("", "*.toml") defer os.Remove(tmp.Name()) defer tmp.Close() fmt.Fprintln(tmp, `name = "Cool"`) - fmt.Fprintln(tmp, "[conn]") + fmt.Fprintln(tmp, "[stores]") fmt.Fprintln(tmp, `store = "sqlite"`) - fmt.Fprintln(tmp, "[conn.settings]") + fmt.Fprintln(tmp, "[stores.settings.sqlite]") + fmt.Fprintln(tmp, `path = "tmp"`) fmt.Fprintln(tmp, `num = 42`) c, e := LoadFromToml(tmp.Name()) assert.NoError(t, e) - assert.Equal(t, "Cool", c.Name) - assert.Equal(t, "sqlite", c.Conn.Store) - assert.Equal(t, int64(42), c.Conn.Settings["num"]) + assert.Equal(t, "Cool", c.Name()) + + st, err := c.Store("") + assert.NoError(t, err) + + assert.Equal(t, "sqlite", st.Name()) + + var sett sqlSett + err = st.Decode(&sett) + assert.NoError(t, err) + assert.Equal(t, 42, sett.Num) + assert.Equal(t, "tmp", sett.Path) } diff --git a/internal/testmocks/config/config_mock.go b/internal/testmocks/config/config_mock.go new file mode 100644 index 0000000..f3b14ec --- /dev/null +++ b/internal/testmocks/config/config_mock.go @@ -0,0 +1,371 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: interface.go +// +// Generated by this command: +// +// mockgen -source interface.go -destination ../internal/testmocks/config/config_mock.go -package config -typed +// + +// Package config is a generated GoMock package. +package config + +import ( + reflect "reflect" + + config "codeberg.org/danjones000/combluotion/config" + gomock "go.uber.org/mock/gomock" +) + +// MockConfig is a mock of Config interface. +type MockConfig struct { + ctrl *gomock.Controller + recorder *MockConfigMockRecorder + isgomock struct{} +} + +// MockConfigMockRecorder is the mock recorder for MockConfig. +type MockConfigMockRecorder struct { + mock *MockConfig +} + +// NewMockConfig creates a new mock instance. +func NewMockConfig(ctrl *gomock.Controller) *MockConfig { + mock := &MockConfig{ctrl: ctrl} + mock.recorder = &MockConfigMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockConfig) EXPECT() *MockConfigMockRecorder { + return m.recorder +} + +// BaseURL mocks base method. +func (m *MockConfig) BaseURL() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BaseURL") + ret0, _ := ret[0].(string) + return ret0 +} + +// BaseURL indicates an expected call of BaseURL. +func (mr *MockConfigMockRecorder) BaseURL() *MockConfigBaseURLCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaseURL", reflect.TypeOf((*MockConfig)(nil).BaseURL)) + return &MockConfigBaseURLCall{Call: call} +} + +// MockConfigBaseURLCall wrap *gomock.Call +type MockConfigBaseURLCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockConfigBaseURLCall) Return(arg0 string) *MockConfigBaseURLCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockConfigBaseURLCall) Do(f func() string) *MockConfigBaseURLCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockConfigBaseURLCall) DoAndReturn(f func() string) *MockConfigBaseURLCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Env mocks base method. +func (m *MockConfig) Env() config.Env { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Env") + ret0, _ := ret[0].(config.Env) + return ret0 +} + +// Env indicates an expected call of Env. +func (mr *MockConfigMockRecorder) Env() *MockConfigEnvCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Env", reflect.TypeOf((*MockConfig)(nil).Env)) + return &MockConfigEnvCall{Call: call} +} + +// MockConfigEnvCall wrap *gomock.Call +type MockConfigEnvCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockConfigEnvCall) Return(arg0 config.Env) *MockConfigEnvCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockConfigEnvCall) Do(f func() config.Env) *MockConfigEnvCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockConfigEnvCall) DoAndReturn(f func() config.Env) *MockConfigEnvCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Name mocks base method. +func (m *MockConfig) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name. +func (mr *MockConfigMockRecorder) Name() *MockConfigNameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfig)(nil).Name)) + return &MockConfigNameCall{Call: call} +} + +// MockConfigNameCall wrap *gomock.Call +type MockConfigNameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockConfigNameCall) Return(arg0 string) *MockConfigNameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockConfigNameCall) Do(f func() string) *MockConfigNameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockConfigNameCall) DoAndReturn(f func() string) *MockConfigNameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Store mocks base method. +func (m *MockConfig) Store(name string) (config.Store, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Store", name) + ret0, _ := ret[0].(config.Store) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Store indicates an expected call of Store. +func (mr *MockConfigMockRecorder) Store(name any) *MockConfigStoreCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Store", reflect.TypeOf((*MockConfig)(nil).Store), name) + return &MockConfigStoreCall{Call: call} +} + +// MockConfigStoreCall wrap *gomock.Call +type MockConfigStoreCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockConfigStoreCall) Return(arg0 config.Store, arg1 error) *MockConfigStoreCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockConfigStoreCall) Do(f func(string) (config.Store, error)) *MockConfigStoreCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockConfigStoreCall) DoAndReturn(f func(string) (config.Store, error)) *MockConfigStoreCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StoreName mocks base method. +func (m *MockConfig) StoreName() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoreName") + ret0, _ := ret[0].(string) + return ret0 +} + +// StoreName indicates an expected call of StoreName. +func (mr *MockConfigMockRecorder) StoreName() *MockConfigStoreNameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreName", reflect.TypeOf((*MockConfig)(nil).StoreName)) + return &MockConfigStoreNameCall{Call: call} +} + +// MockConfigStoreNameCall wrap *gomock.Call +type MockConfigStoreNameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockConfigStoreNameCall) Return(arg0 string) *MockConfigStoreNameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockConfigStoreNameCall) Do(f func() string) *MockConfigStoreNameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockConfigStoreNameCall) DoAndReturn(f func() string) *MockConfigStoreNameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockStore is a mock of Store interface. +type MockStore struct { + ctrl *gomock.Controller + recorder *MockStoreMockRecorder + isgomock struct{} +} + +// MockStoreMockRecorder is the mock recorder for MockStore. +type MockStoreMockRecorder struct { + mock *MockStore +} + +// NewMockStore creates a new mock instance. +func NewMockStore(ctrl *gomock.Controller) *MockStore { + mock := &MockStore{ctrl: ctrl} + mock.recorder = &MockStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStore) EXPECT() *MockStoreMockRecorder { + return m.recorder +} + +// Decode mocks base method. +func (m *MockStore) Decode(v any) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decode", v) + ret0, _ := ret[0].(error) + return ret0 +} + +// Decode indicates an expected call of Decode. +func (mr *MockStoreMockRecorder) Decode(v any) *MockStoreDecodeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockStore)(nil).Decode), v) + return &MockStoreDecodeCall{Call: call} +} + +// MockStoreDecodeCall wrap *gomock.Call +type MockStoreDecodeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreDecodeCall) Return(arg0 error) *MockStoreDecodeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreDecodeCall) Do(f func(any) error) *MockStoreDecodeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreDecodeCall) DoAndReturn(f func(any) error) *MockStoreDecodeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Map mocks base method. +func (m *MockStore) Map() (map[string]any, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Map") + ret0, _ := ret[0].(map[string]any) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Map indicates an expected call of Map. +func (mr *MockStoreMockRecorder) Map() *MockStoreMapCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockStore)(nil).Map)) + return &MockStoreMapCall{Call: call} +} + +// MockStoreMapCall wrap *gomock.Call +type MockStoreMapCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreMapCall) Return(arg0 map[string]any, arg1 error) *MockStoreMapCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreMapCall) Do(f func() (map[string]any, error)) *MockStoreMapCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreMapCall) DoAndReturn(f func() (map[string]any, error)) *MockStoreMapCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Name mocks base method. +func (m *MockStore) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name. +func (mr *MockStoreMockRecorder) Name() *MockStoreNameCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockStore)(nil).Name)) + return &MockStoreNameCall{Call: call} +} + +// MockStoreNameCall wrap *gomock.Call +type MockStoreNameCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStoreNameCall) Return(arg0 string) *MockStoreNameCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStoreNameCall) Do(f func() string) *MockStoreNameCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStoreNameCall) DoAndReturn(f func() string) *MockStoreNameCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/store/factory.go b/store/factory.go index 4d19fc4..5bf2307 100644 --- a/store/factory.go +++ b/store/factory.go @@ -9,7 +9,7 @@ import ( var ErrNoFactory = errors.New("unknown factory") -type StoreFactory func(config.Config) (Store, error) +type StoreFactory func(config.Store) (Store, error) var factories map[string]StoreFactory @@ -26,13 +26,18 @@ func GetFactory(name string) StoreFactory { } func MakeStore(name string, conf config.Config) (Store, error) { + st, err := conf.Store(name) + if err != nil { + return nil, err + } + if name == "" { - name = conf.Conn.Store + name = st.Name() } f, ok := factories[name] if !ok { return nil, fmt.Errorf("%w: %s", ErrNoFactory, name) } - return f(conf) + return f(st) } diff --git a/store/factory_test.go b/store/factory_test.go index f4aa205..6d3ed8f 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -7,20 +7,31 @@ import ( "go.uber.org/mock/gomock" "codeberg.org/danjones000/combluotion/config" + confMock "codeberg.org/danjones000/combluotion/internal/testmocks/config" storeMock "codeberg.org/danjones000/combluotion/internal/testmocks/store" ) -func getStoreFactory(t *testing.T) (*gomock.Controller, StoreFactory) { +type testHelp struct { + ctrl *gomock.Controller + store *storeMock.MockStore + fact StoreFactory + conf *confMock.MockConfig +} + +func setupFactoryTest(t *testing.T) testHelp { t.Helper() ctrl := gomock.NewController(t) - return ctrl, func(config.Config) (Store, error) { - return storeMock.NewMockStore(ctrl), nil + store := storeMock.NewMockStore(ctrl) + fact := func(config.Store) (Store, error) { + return store, nil } + + return testHelp{ctrl, store, fact, confMock.NewMockConfig(ctrl)} } func TestAddFactory(t *testing.T) { - _, f := getStoreFactory(t) - AddFactory("mock", f) + th := setupFactoryTest(t) + AddFactory("mock", th.fact) defer delete(factories, "mock") _, ok := factories["mock"] assert.True(t, ok) @@ -32,36 +43,52 @@ func TestGetFactoryNil(t *testing.T) { } func TestGetFactoryNotNil(t *testing.T) { - _, f := getStoreFactory(t) - AddFactory("mock", f) + th := setupFactoryTest(t) + AddFactory("mock", th.fact) defer delete(factories, "mock") - f = GetFactory("mock") + f := GetFactory("mock") assert.NotNil(t, f) } func TestMakeStoreError(t *testing.T) { - s, e := MakeStore("mock", config.Config{}) + th := setupFactoryTest(t) + th.conf. + EXPECT(). + Store("mock"). + Return(nil, nil) + s, e := MakeStore("mock", th.conf) assert.Nil(t, s) assert.ErrorIs(t, e, ErrNoFactory) assert.ErrorContains(t, e, ErrNoFactory.Error()+": mock") } func TestMakeStoreNoError(t *testing.T) { - _, f := getStoreFactory(t) - AddFactory("mock", f) + th := setupFactoryTest(t) + th.conf. + EXPECT(). + Store("mock"). + Return(nil, nil) + AddFactory("mock", th.fact) defer delete(factories, "mock") - s, e := MakeStore("mock", config.Config{}) + s, e := MakeStore("mock", th.conf) assert.NotNil(t, s) assert.NoError(t, e) } func TestMakeStoreNoName(t *testing.T) { - _, f := getStoreFactory(t) - AddFactory("mock", f) + th := setupFactoryTest(t) + confStore := confMock.NewMockStore(th.ctrl) + th.conf. + EXPECT(). + Store(""). + Return(confStore, nil) + confStore. + EXPECT(). + Name(). + Return("mock") + AddFactory("mock", th.fact) defer delete(factories, "mock") - s, e := MakeStore("", config.Config{ - Conn: config.ConnSettings{Store: "mock"}, - }) + s, e := MakeStore("", th.conf) assert.NotNil(t, s) assert.NoError(t, e) } diff --git a/store/sqlite/repo.go b/store/sqlite/repo.go index c0e780e..f2fca17 100644 --- a/store/sqlite/repo.go +++ b/store/sqlite/repo.go @@ -10,8 +10,17 @@ func init() { store.AddFactory("sqlite", MakeStore) } -func MakeStore(conf config.Config) (store.Store, error) { - sqlConf := sqlite.Config{Path: conf.Conn.DSN} +type settings struct { + Path string +} + +func MakeStore(conf config.Store) (store.Store, error) { + var s settings + err := conf.Decode(&s) + if err != nil { + return nil, err + } + sqlConf := sqlite.Config{Path: s.Path} db, err := sqlite.New(sqlConf) if err != nil { return nil, err From d7de194a90ea25db844eb095e0af8b0d8d29b080 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Mon, 27 Jan 2025 11:41:32 -0600 Subject: [PATCH 20/22] =?UTF-8?q?=E2=9C=85=20Improve=20test=20coverage?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app.go | 1 + app_test.go | 25 +++++++++++++++++++++++++ config/config_test.go | 38 ++++++++++++++++++++++++++++++++++++++ store/factory_test.go | 11 +++++++++++ 4 files changed, 75 insertions(+) diff --git a/app.go b/app.go index fbe7524..48caeaf 100644 --- a/app.go +++ b/app.go @@ -33,6 +33,7 @@ func NewApp(ver string, conf config.Config, db store.Store) (*App, error) { app := App{ version: ver, conf: conf, + storage: db, } selfIRI := boxap.DefaultServiceIRI(conf.BaseURL()) diff --git a/app_test.go b/app_test.go index 7819765..edcc536 100644 --- a/app_test.go +++ b/app_test.go @@ -78,6 +78,31 @@ func TestService(t *testing.T) { } } +func TestAppStorage(t *testing.T) { + th := setupAppTest(t) + base := "http://localhost:1234/" + th.conf.EXPECT().BaseURL().Return(base).MinTimes(1) + th.conf.EXPECT().Name().Return("").AnyTimes() + a, er := NewApp("0.0.0.0", th.conf, th.store) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Equal(t, th.store, a.Storage()) + } +} + +func TestAppUser(t *testing.T) { + // TODO: Actually fill this out at some point + th := setupAppTest(t) + base := "http://localhost:1234/" + th.conf.EXPECT().BaseURL().Return(base).MinTimes(1) + th.conf.EXPECT().Name().Return("").AnyTimes() + a, er := NewApp("0.0.0.0", th.conf, th.store) + assert.NoError(t, er) + if assert.NotNil(t, a) { + assert.Zero(t, a.User()) + } +} + func TestStrings(t *testing.T) { cases := [...]struct { given string diff --git a/config/config_test.go b/config/config_test.go index 28dfc9f..c146f7f 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -3,6 +3,7 @@ package config import ( "testing" + "github.com/BurntSushi/toml" "github.com/stretchr/testify/assert" ) @@ -24,3 +25,40 @@ func TestValidEnvReturnsCorrect(t *testing.T) { }) } } + +func TestConfigBaseURL(t *testing.T) { + c := config{baseURL: "https://me.goodevilgenius.org"} + assert.Equal(t, c.baseURL, c.BaseURL()) +} + +func TestConfigStoreName(t *testing.T) { + c := config{stores: stores{store: "cockroachdb"}} + assert.Equal(t, c.stores.store, c.StoreName()) +} + +func TestStoresMissingStore(t *testing.T) { + ss := stores{} + st, er := ss.GetStore("cockroachdb") + assert.Nil(t, st) + assert.ErrorIs(t, er, ErrMissingStore) +} + +var mockToml = ` +[cockroachdb] + +dsn = "cockroachdb://user:pass@127.0.0.1:26257/combluotion" +` + +type mockConn struct { + CockroachDB toml.Primitive +} + +func TestStoreMap(t *testing.T) { + var conn mockConn + md, _ := toml.Decode(mockToml, &conn) + st := store{"cockroachdb", conn.CockroachDB, md} + + m, er := st.Map() + assert.NoError(t, er) + assert.Equal(t, "cockroachdb://user:pass@127.0.0.1:26257/combluotion", m["dsn"]) +} diff --git a/store/factory_test.go b/store/factory_test.go index 6d3ed8f..aa97fdc 100644 --- a/store/factory_test.go +++ b/store/factory_test.go @@ -1,6 +1,7 @@ package store import ( + "errors" "testing" "github.com/stretchr/testify/assert" @@ -92,3 +93,13 @@ func TestMakeStoreNoName(t *testing.T) { assert.NotNil(t, s) assert.NoError(t, e) } + +func TestMakeStoreConfError(t *testing.T) { + th := setupFactoryTest(t) + mockError := errors.New("leave me alone") + th.conf.EXPECT().Store("mock").Return(nil, mockError) + s, e := MakeStore("mock", th.conf) + assert.Zero(t, s) + assert.ErrorIs(t, e, mockError) + +} From 917f919401d8d37c85ecb55f9eebcab085c75dd7 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Mon, 27 Jan 2025 15:23:46 -0600 Subject: [PATCH 21/22] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Use=20uint8=20for=20?= =?UTF-8?q?Env?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cmd/combluotion/main.go | 1 + config/config_test.go | 2 +- config/env.go | 44 ++++++++++++++++++----- config/env_string.go | 27 ++++++++++++++ config/env_test.go | 80 +++++++++++++++++++++++++++++++++++------ config/load_test.go | 2 ++ 6 files changed, 135 insertions(+), 21 deletions(-) create mode 100644 config/env_string.go diff --git a/cmd/combluotion/main.go b/cmd/combluotion/main.go index 5557203..21b30d7 100644 --- a/cmd/combluotion/main.go +++ b/cmd/combluotion/main.go @@ -49,6 +49,7 @@ func getTomlFile() string { var confStr = ` base_url = "http://localhost:4523/" +env = "dev" [stores] store = "sqlite" diff --git a/config/config_test.go b/config/config_test.go index c146f7f..7c17fb2 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -13,7 +13,7 @@ func TestEnvDefaultsToDev(t *testing.T) { } func TestInvalidEnvReturnsDev(t *testing.T) { - c := config{env: Env("foobar")} + c := config{env: Env(255)} assert.Equal(t, Dev, c.Env()) } diff --git a/config/env.go b/config/env.go index b38e4fd..b8e2f43 100644 --- a/config/env.go +++ b/config/env.go @@ -1,12 +1,20 @@ package config -type Env string +import ( + "errors" + "fmt" + "strings" +) + +//go:generate stringer -type Env + +type Env uint8 const ( - Dev Env = "dev" - Prod Env = "prod" - Qa Env = "qa" - Test Env = "test" + Dev Env = iota + 1 + Prod + Qa + Test ) var Envs = [...]Env{ @@ -16,6 +24,28 @@ var Envs = [...]Env{ Test, } +func (e Env) MarshalText() ([]byte, error) { + return []byte(e.String()), nil +} + +var ErrEnvUnmarshal = errors.New("unable to unmarshal value") + +func (e *Env) UnmarshalText(text []byte) error { + if e == nil { + return fmt.Errorf("%w: nil pointer", ErrEnvUnmarshal) + } + + val := strings.ToUpper(string(text)) + + for _, ee := range Envs { + if val == strings.ToUpper(ee.String()) { + *e = ee + return nil + } + } + return fmt.Errorf("%w: invalid value: %s", ErrEnvUnmarshal, text) +} + func ValidEnvOrDev(e Env) Env { if ValidEnv(e) { return e @@ -31,7 +61,3 @@ func ValidEnv(env Env) bool { } return false } - -func (e Env) String() string { - return string(e) -} diff --git a/config/env_string.go b/config/env_string.go new file mode 100644 index 0000000..5fe0f83 --- /dev/null +++ b/config/env_string.go @@ -0,0 +1,27 @@ +// Code generated by "stringer -type Env"; DO NOT EDIT. + +package config + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[Dev-1] + _ = x[Prod-2] + _ = x[Qa-3] + _ = x[Test-4] +} + +const _Env_name = "DevProdQaTest" + +var _Env_index = [...]uint8{0, 3, 7, 9, 13} + +func (i Env) String() string { + i -= 1 + if i >= Env(len(_Env_index)-1) { + return "Env(" + strconv.FormatInt(int64(i+1), 10) + ")" + } + return _Env_name[_Env_index[i]:_Env_index[i+1]] +} diff --git a/config/env_test.go b/config/env_test.go index 680a79b..afb6507 100644 --- a/config/env_test.go +++ b/config/env_test.go @@ -1,21 +1,81 @@ package config import ( + "encoding" + "fmt" + "strings" "testing" "github.com/stretchr/testify/assert" ) +var _ encoding.TextMarshaler = Env(0) +var _ encoding.TextUnmarshaler = new(Env) +var _ fmt.Stringer = Env(0) + func TestEnvString(t *testing.T) { - cases := Envs[:] - cases = append(cases, Env("foobar"), Env(""), Env("42"), Env("✨")) - for _, e := range cases { - t.Run(string(e), func(t *testing.T) { - assert.Equal(t, string(e), e.String()) + testcases := []struct { + expected string + val Env + }{ + {"Dev", Dev}, + {"Prod", Prod}, + {"Qa", Qa}, + {"Test", Test}, + {"Env(0)", Env(0)}, + {"Env(255)", Env(255)}, + } + for _, testcase := range testcases { + t.Run(testcase.expected, func(sub *testing.T) { + assert.Equal(t, testcase.expected, testcase.val.String()) + by, er := testcase.val.MarshalText() + assert.NoError(t, er) + assert.Equal(t, []byte(testcase.expected), by) }) } } +type unmarshaltest struct { + name string + in []byte + exp Env + err string +} + +func TestEnvUnmarshalText(t *testing.T) { + testcases := []unmarshaltest{ + {"empty", []byte{}, Env(0), "invalid value: "}, + {"bad value", []byte("foobar"), Env(0), "invalid value: foobar"}, + } + for _, e := range Envs { + testcases = append(testcases, unmarshaltest{e.String() + "-lower", []byte(strings.ToLower(e.String())), e, ""}) + testcases = append(testcases, unmarshaltest{e.String() + "-upper", []byte(strings.ToUpper(e.String())), e, ""}) + testcases = append(testcases, unmarshaltest{e.String(), []byte(e.String()), e, ""}) + } + + for _, testcase := range testcases { + t.Run(testcase.name, func(sub *testing.T) { + var e Env + er := (&e).UnmarshalText(testcase.in) + if testcase.err == "" { + assert.NoError(t, er) + assert.Equal(t, testcase.exp, e) + } else { + assert.Empty(t, e) + assert.ErrorContains(t, er, testcase.err) + assert.ErrorIs(t, er, ErrEnvUnmarshal) + } + }) + } +} + +func TestEnvUnmarshalTextNil(t *testing.T) { + var e *Env + er := e.UnmarshalText([]byte("prod")) + assert.ErrorContains(t, er, "nil pointer") + assert.ErrorIs(t, er, ErrEnvUnmarshal) +} + func TestValidEnv(t *testing.T) { cases := [...]struct { e Env @@ -25,9 +85,8 @@ func TestValidEnv(t *testing.T) { {Prod, true}, {Qa, true}, {Test, true}, - {Env("foobar"), false}, - {Env(""), false}, - {Env("✨"), false}, + {Env(0), false}, + {Env(255), false}, } for _, c := range cases { @@ -46,9 +105,8 @@ func TestValidEnvOrDev(t *testing.T) { {Prod, Prod}, {Qa, Qa}, {Test, Test}, - {Env("foobar"), Dev}, - {Env(""), Dev}, - {Env("✨"), Dev}, + {Env(0), Dev}, + {Env(255), Dev}, } for _, c := range cases { diff --git a/config/load_test.go b/config/load_test.go index a7f4d1a..78f266c 100644 --- a/config/load_test.go +++ b/config/load_test.go @@ -23,6 +23,7 @@ func TestLoadTomlGood(t *testing.T) { defer os.Remove(tmp.Name()) defer tmp.Close() fmt.Fprintln(tmp, `name = "Cool"`) + fmt.Fprintln(tmp, `env = "prod"`) fmt.Fprintln(tmp, "[stores]") fmt.Fprintln(tmp, `store = "sqlite"`) fmt.Fprintln(tmp, "[stores.settings.sqlite]") @@ -31,6 +32,7 @@ func TestLoadTomlGood(t *testing.T) { c, e := LoadFromToml(tmp.Name()) assert.NoError(t, e) assert.Equal(t, "Cool", c.Name()) + assert.Equal(t, Prod, c.Env()) st, err := c.Store("") assert.NoError(t, err) From fe860fbc8290f1c35fa75c4fbbb34d33b5e05563 Mon Sep 17 00:00:00 2001 From: Dan Jones Date: Mon, 27 Jan 2025 17:18:09 -0600 Subject: [PATCH 22/22] =?UTF-8?q?=F0=9F=9B=A0=20Add=20vulnerability=20chec?= =?UTF-8?q?kRename=20analyze=20check=20to=20lint?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Taskfile.yml | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Taskfile.yml b/Taskfile.yml index 933454b..95f6937 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -43,12 +43,20 @@ tasks: cmds: - staticcheck ./... - analyze: + vuln: + desc: Check for vulnerabilities + sources: + - '**/*.go' + cmds: + - govulncheck ./... + + lint: desc: Do static analysis deps: - vet - critic - staticcheck + - vuln test: desc: Run unit tests