tribes-plugin-kobold/test/kobold/api_test.exs

defmodule TribeOne.TribesPlugin.Kobold.APITest do
  use Tribes.PluginTest.PageCase, plugin: TribeOne.TribesPlugin.Kobold.Plugin

  alias TribeOne.TribesPlugin.Kobold.API

  test "creates public and private datasets with schema-backed records" do
    run_id = "kobold-api-#{System.unique_integer([:positive])}"

    assert {:ok, %{ok: true, deleted: _}} = API.reset(%{"run_id" => run_id})

    assert {:ok, %{ok: true, dataset: public_dataset}} =
             API.create_dataset(%{
               "run_id" => run_id,
               "name" => "Public seed catalog",
               "visibility" => "public"
             })

    assert public_dataset.visibility == "public"
    assert public_dataset.replication_mode == "public_read"

    assert {:ok, %{ok: true, dataset: private_dataset}} =
             API.create_dataset(%{
               "run_id" => run_id,
               "name" => "Private notes",
               "visibility" => "private"
             })

    assert private_dataset.visibility == "private"
    assert private_dataset.replication_mode == "local_only"

    assert {:ok, %{ok: true, resource: resource}} =
             API.create_resource_definition(%{
               "dataset_id" => public_dataset.id,
               "name" => "SeedVariety",
               "fields" => %{
                 "species" => %{"type" => "string", "required" => true},
                 "germination_days" => %{"type" => "integer"}
               }
             })

    assert resource.name == "SeedVariety"

    assert {:ok, %{ok: true, commit: commit, bookmark: bookmark, event: event, record: record}} =
             API.upsert_record(%{
               "dataset_id" => public_dataset.id,
               "resource_name" => "SeedVariety",
               "fields" => %{"species" => "Tomato", "germination_days" => 8}
             })

    assert commit.operations == [
             %{
               "op" => "upsert",
               "resource_name" => "SeedVariety",
               "record_id" => record.record_id,
               "fields" => %{"species" => "Tomato", "germination_days" => 8},
               "metadata" => %{},
               "actor_pubkey" => nil
             }
           ]

    assert bookmark.name == "main"
    assert bookmark.commit_id == commit.id
    assert event.event_type == "record_upsert"
    assert event.commit_id == commit.id
    assert record.fields == %{"species" => "Tomato", "germination_days" => 8}
    assert record.head_commit_id == commit.id

    assert {:ok,
            %{
              ok: true,
              datasets: datasets,
              records: records,
              commits: commits,
              bookmarks: bookmarks
            }} =
             API.state(%{"run_id" => run_id})

    assert Enum.map(datasets, & &1.name) |> Enum.sort() == [
             "Private notes",
             "Public seed catalog"
           ]

    assert [%{fields: %{"species" => "Tomato"}}] = records
    assert [%{id: commit_id}] = commits
    assert [%{name: "main", commit_id: ^commit_id}] = bookmarks
  end

  test "remote tribe access uses generic permission rules" do
    run_id = "kobold-access-#{System.unique_integer([:positive])}"
    remote = "remote-access-tribe"

    assert {:ok, %{dataset: dataset}} =
             API.create_dataset(%{
               "run_id" => run_id,
               "name" => "Shared notes",
               "visibility" => "private"
             })

    assert {:ok, %{resource: _resource}} =
             API.create_resource_definition(%{
               "dataset_id" => dataset.id,
               "name" => "Entry",
               "fields" => %{"title" => %{"type" => "string", "required" => true}}
             })

    assert {:ok, %{datasets: []}} =
             API.state(%{"run_id" => run_id, "remote_tribe_pubkey" => remote})

    assert {:error, :access_denied} =
             API.upsert_record(%{
               "dataset_id" => dataset.id,
               "resource_name" => "Entry",
               "remote_tribe_pubkey" => remote,
               "fields" => %{"title" => "Denied"}
             })

    assert {:ok, _rule} =
             Tribes.Access.put_rule(%{
               plugin_name: "tribe-one-kobold",
               resource_type: "kobold.dataset",
               resource_id: dataset.id,
               action: "read",
               subject_type: "tribe",
               subject_id: remote,
               effect: "allow"
             })

    assert {:ok, %{datasets: [%{id: dataset_id}]}} =
             API.state(%{"run_id" => run_id, "remote_tribe_pubkey" => remote})

    assert dataset_id == dataset.id

    assert {:ok, _rule} =
             Tribes.Access.put_rule(%{
               plugin_name: "tribe-one-kobold",
               resource_type: "kobold.dataset",
               resource_id: dataset.id,
               action: "write",
               subject_type: "tribe",
               subject_id: remote,
               effect: "allow"
             })

    assert {:ok, %{record: %{fields: %{"title" => "Allowed"}}}} =
             API.upsert_record(%{
               "dataset_id" => dataset.id,
               "resource_name" => "Entry",
               "remote_tribe_pubkey" => remote,
               "fields" => %{"title" => "Allowed"}
             })
  end

  test "record validation uses resource definition fields" do
    run_id = "kobold-validation-#{System.unique_integer([:positive])}"

    assert {:ok, %{dataset: dataset}} =
             API.create_dataset(%{
               "run_id" => run_id,
               "name" => "Validation",
               "visibility" => "private"
             })

    assert {:ok, %{resource: _resource}} =
             API.create_resource_definition(%{
               "dataset_id" => dataset.id,
               "name" => "Entry",
               "fields" => %{"title" => %{"type" => "string", "required" => true}}
             })

    assert {:error, "missing required field title"} =
             API.upsert_record(%{
               "dataset_id" => dataset.id,
               "resource_name" => "Entry",
               "fields" => %{}
             })
  end
end