@voxgig/create-sdkgen 0.0.2 → 0.0.3

package/tm/standard/src/go/Quick_go.ts

@@ -0,0 +1,108 @@
+
+import { cmp, File, Content } from '@voxgig/sdkgen'
+
+
+const Quick = cmp(function Quick(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  File({ name: 'quick_test.' + build.name }, () => {
+
+    Content(`
+package ${model.name}sdk
+
+import (
+  "log"
+  "os"
+  "strings"
+  "testing"
+
+  "github.com/joho/godotenv"
+)
+
+func TestQuick(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Quick test") 
+  }
+
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client Quick: %q", err)
+  }
+
+  data := GeofenceData{
+    Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
+  }
+
+  out, err := client.Geofence().Load(data)
+  if err != nil {
+    t.Fatalf("Error running Quick load method: %q", err)
+  }
+  log.Print("Geofence.load", out.Data)
+
+  out2, err := client.Geofence().List()
+  if err != nil {
+    t.Fatalf("Error running Quick list method: %q", err)
+  }
+  log.Print("Geofence.list", out2[0].Data, out2[1].Data)
+
+  if strings.Contains(endpoint, "localhost") {
+    //Create Quick Test
+    data := GeofenceData{
+      Name: "Geofence 1",
+      Desc: "Geofence 1 description",
+      Extent_id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
+      Custom: map[string]any{
+        "foo": "bar",
+      },
+    }
+    out, err := client.Geofence().Create(data)
+    if err != nil {
+      t.Fatalf("Error running Quick create method: %q", err)
+    }
+    log.Print("Geofence.create", out.Data)
+
+    //Save Quick Test
+    data = GeofenceData{
+      Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
+      Name: "Geofence 1",
+      Desc: "Geofence 1 description",
+      Extent_id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
+      Custom: map[string]any{
+        "foo": "bar",
+      },
+    }
+    out, err = client.Geofence().Save(data)
+    if err != nil {
+      t.Fatalf("Error running Quick save method: %q", err)
+    }
+    log.Print("Geofence.save", out.Data)
+
+    //Remove Quick Test
+    data = GeofenceData{
+      Id: "CF49B47C-317B-4387-83C3-4A23715B1C45",
+    }
+    out, err = client.Geofence().Remove(data)
+    if err != nil {
+      t.Fatalf("Error running Quick remove method: %q", err)
+    }
+    log.Print("Geofence.remove ", out)
+  }
+}
+`)
+
+  })
+})
+
+
+export {
+  Quick
+}
+

package/tm/standard/src/go/ReadmeInstall_go.ts

@@ -0,0 +1,19 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { build } = props
+
+  Content('```go')
+  Content(`
+go get ${build.module.name}
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeInstall
+}

package/tm/standard/src/go/ReadmeQuick_go.ts

@@ -0,0 +1,45 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { build, ctx$: { model } } = props
+
+  Content('```go')
+  Content(`
+package main
+
+import (
+  "log"
+  "os"
+
+  "${build.module.name}"
+)
+
+func main() {
+  var options ${model.name}sdk.Options
+  options.Apikey = os.Getenv("${model.NAME}_APIKEY")
+  options.Endpoint = os.Getenv("${model.NAME}_ENDPOINT")
+
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    log.Fatal(err)
+  }
+
+  buildings, err := client.Building().List()
+  if err != nil {
+    log.Println("Error running building list:", err)
+    return
+  }
+
+  log.Println("Buildings", buildings)
+}
+`)
+  Content('```')
+
+})
+
+
+export {
+  ReadmeQuick
+}

package/tm/standard/src/go/TestAcceptEntity_go.ts

@@ -0,0 +1,219 @@
+
+import { cmp, each, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestAcceptEntity = cmp(function TestAcceptEntity(props: any) {
+  const { model, entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  const valueMap: Record<string, any> = {
+    "custom": "map[string]any{\"test\": \"test\"}",
+    "xval": "rand.Float64()",
+    "yval": "rand.Float64()",
+    "zval": "rand.Float64()",
+    "xlen": "rand.Int()",
+    "ylen": "rand.Int()",
+    "parent_xlen": "rand.Int()",
+    "parent_xval": "rand.Float64()",
+    "parent_xyangle": "rand.Float64()",
+    "parent_ylen": "rand.Int()",
+    "parent_yval": "rand.Float64()",
+    "parent_zval": "rand.Float64()",
+    "polygon": "struct{Points [][]float64}{[][]float64{{ 1.34},{12.33}}}",
+    "has_parent": true,
+    "primary": true,
+  }
+
+  Content(`
+func Test${entity.Name}AcceptList(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptList")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} list: %q", err)
+  }
+
+  entities, err := client.${entity.Name}().List()
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} list method: %v", err)
+  }
+
+  if len(entities) == 0 {
+    t.Fatalf("Error getting ${entity.name} accept list length == 0 and got %v", 
+     len(entities))
+  }
+
+  got := entities[0].Data
+
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept list - id equal to empty string")
+  }
+}
+
+
+func Test${entity.Name}AcceptLoad(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptLoad")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} load: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    Id: "t01",
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Load(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} load method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept load - id equal to empty string") 
+  }
+}
+
+func Test${entity.Name}AcceptCreate(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptCreate")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} create: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    `)
+  each(entity.field, (field: any) => {
+    const value = valueMap[field.name] ? valueMap[field.name] : field.type
+
+    if (value == "string") {
+      Content(`
+    ${field.Name}: "test",
+            `)
+      return
+    }
+    Content(`
+    ${field.Name}: ${value},
+            `)
+  })
+  Content(`
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Create(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} create method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept create - id equal to empty string") 
+  }
+}
+
+
+func Test${entity.Name}AcceptSave(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptSave")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} save: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    `)
+  each(entity.field, (field: any) => {
+    const value = valueMap[field.name] ? valueMap[field.name] : field.type
+
+    if (value == "string") {
+      Content(`
+    ${field.Name}: "test",
+            `)
+      return
+    }
+    Content(`
+    ${field.Name}: ${value},
+            `)
+  })
+  Content(`
+  }
+
+  client${entity.Name}, err := client.${entity.Name}().Save(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} save method: %v", err)
+  }
+
+  got := client${entity.Name}.Data
+  
+  if got.Id == "" {
+    t.Fatal("Error getting ${entity.name} accept create - id equal to empty string") 
+  }
+}
+
+func Test${entity.Name}AcceptRemove(t *testing.T) {
+  err := godotenv.Load()
+  if err != nil {
+    t.Fatal("Error loading .env file for Test${entity.Name}AcceptRemove")
+  }
+  endpoint := os.Getenv("${model.NAME}_ENDPOINT")
+  apikey := os.Getenv("${model.NAME}_APIKEY")
+
+  var options ${model.name}sdk.Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := ${model.name}sdk.Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} remove: %q", err)
+  }
+
+  data := ${model.name}sdk.${entity.Name}Data{
+    Id: "t01",
+  }
+
+  _, err = client.${entity.Name}().Remove(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} remove method: %v", err)
+  }
+}
+`);
+})
+
+
+export {
+  TestAcceptEntity
+}

package/tm/standard/src/go/TestAccept_go.ts

@@ -0,0 +1,38 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+import { TestAcceptEntity } from './TestAcceptEntity_go'
+
+
+const TestAccept = cmp(function TestAccept(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+
+  File({ name: model.name + 'sdk_accept_test.' + build.name }, () => {
+
+    Content(`
+package ${model.name}sdk_test
+
+import (
+  "math/rand"
+  "testing"
+  "os"
+
+  "github.com/joho/godotenv"
+  "github.com/${model.name}/${model.name}-sdk"
+)
+         `)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestAcceptEntity({ model, build, entity })
+    })
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+

package/tm/standard/src/go/TestEntity_go.ts

@@ -0,0 +1,79 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+func Test${entity.Name}List(t *testing.T) {
+  endpoint := "http://test.com"
+  apikey := "apikey"
+  want := ${entity.Name}Data{
+    Id: "${entity.name}t01",
+    Name: "${entity.Name}T01",
+  }
+
+  var options Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} list: %q", err)
+  }
+
+  respData := strings.NewReader(\`{"list":[{"id":"${entity.name}t01"},
+    {"id":"${entity.name}t02"}]}\`)
+  httpClientMock := createHttpClientMock(respData)
+  client.httpClient = *httpClientMock
+
+  entities, err := client.${entity.Name}().List()
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} list method: %q", err)
+  }
+
+  got := entities[0].Data
+  if got.Id != want.Id {
+    t.Fatalf("Error getting ${entity.name} list want %v and got %v", want, got)
+  }
+}
+
+func Test${entity.Name}Load(t *testing.T) {
+  endpoint := "http://test.com"
+  apikey := "apikey"
+  want := ${entity.Name}Data{
+    Id: "${entity.name}t01",
+  }
+
+  var options Options
+  options.Apikey = apikey
+  options.Endpoint = endpoint
+  client, err := Make(options)
+  if err != nil {
+    t.Fatalf("Error creating a new client ${entity.name} load: %q", err)
+  }
+
+  respData := strings.NewReader(fmt.Sprintf(\`{"id":"${entity.name}t01"}\`))
+  httpClientMock := createHttpClientMock(respData)
+  client.httpClient = *httpClientMock
+
+  data := want
+  client${entity.Name}, err := client.${entity.Name}().Load(data)
+  if err != nil {
+    t.Fatalf("Error running ${entity.name} load method: %q", err)
+  }
+
+  got := client${entity.Name}.Data
+  if got.Id != want.Id {
+    t.Fatalf("Error getting ${entity.name} load want %v and got %v", want.Id, got.Id)
+  }
+}
+`)
+})
+
+
+export {
+  TestEntity
+}

package/tm/standard/src/go/TestMain_go.ts

@@ -0,0 +1,61 @@
+
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_go'
+
+
+const TestMain = cmp(function TestMain(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  File({ name: model.name + 'sdk_test.' + build.name }, () => {
+
+    Content(`
+package ${model.name}sdk
+
+import (
+  "fmt"
+  "testing"
+  "net/http"
+  "io"
+  "strings"
+)
+
+// Mock HTTP Client Transport type.
+// For more info, please see: https://pkg.go.dev/net/http#Client
+// And: https://pkg.go.dev/net/http#RoundTripper
+type fakeService func(*http.Request) (*http.Response, error)
+
+func (s fakeService) RoundTrip(req *http.Request) (*http.Response, error) {
+  return s(req)
+}
+
+func createHttpClientMock(respData *strings.Reader) *http.Client {
+ return &http.Client{
+  Transport: fakeService(func(*http.Request) (*http.Response, error) {
+    return &http.Response{
+      StatusContent: http.StatusOK,
+      Header: http.Header{
+        "Content-Type": []string{"application/json"},
+      },
+      Body: io.NopCloser(respData),
+    }, nil
+  }),
+}}
+`)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestEntity({ model, build, entity })
+    })
+    Content(`
+`)
+
+  })
+})
+
+
+export {
+  TestMain
+}
+

package/tm/standard/src/go/Test_go.ts

@@ -0,0 +1,20 @@
+
+import { cmp } from '@voxgig/sdkgen'
+
+import { Quick } from './Quick_go'
+import { TestMain } from './TestMain_go'
+import { TestAccept } from './TestAccept_go'
+
+
+const Test = cmp(function Test(props: any) {
+  const { build } = props
+
+  Quick({ build })
+  TestMain({ build })
+  TestAccept({ build })
+})
+
+
+export {
+  Test
+}