specs

Documentation

Overview

Package specs

Summary

This package implements generic CRUD operation related testing specifications that commonly appears upon interacting with external resources.

Reason for separate pkg from resources pkg

This package originally was part of the resources pkg, but package "testing" has side effects on import. In order to avoid force the import on the implementations, the specs had to be extracted into a separate package. Since testing#T.Run is heavily used, abstracting testing.T away is difficult.

Minimum Requirement from Resource point of view

In order to make this package work, you have to implement the TestMinimumRequirementsWithExampleEntities specification. Most of the other Resource specs specification depends on the Resource specs mentioned in the min requirement specification. Keep in mind, that you have no guarantee on your Resource content during test execution, because some specification may alter the content of the Resource (db), or delete from it. If you need specific data in the Resource you want to test with, you must ensure in the test execution that such context is correctly provisioned, and after test execution, cleaned up. If you use such data-set in a external Resource that needs to be kept intact, I advise you to use separate environments for test execution and manual testing.

Requirement from Business Entities

This package depends on a fact that there is a string field ID in a business entity struct, or at least a tag `ext:"ID"`. This allows the package to create specifications that assumes, that the ID field links the EntityTypeName structure to an external Resource object. The Resource specs package doesn't care about the content of the ID string field, and don't have assumptions other than the existence of the field ID on a struct

Index

• Constants
• func BenchmarkEntityVolumeCount() int
• func TestUniqConstrain(t *testing.T, r minimumRequirements, e interface{}, f FixtureFactory, ...)
• type CommonSpec
  • func (spec CommonSpec) Benchmark(b *testing.B)
  • func (spec CommonSpec) Test(t *testing.T)
• type CreatorPublisherSpec
  • func (spec CreatorPublisherSpec) Benchmark(b *testing.B)
  • func (spec CreatorPublisherSpec) Spec(s *testcase.Spec)
  • func (spec CreatorPublisherSpec) Test(t *testing.T)
• type CreatorSpec
  • func (spec CreatorSpec) Benchmark(b *testing.B)
  • func (spec CreatorSpec) Test(t *testing.T)
• type DeleterPublisherSpec
  • func (spec DeleterPublisherSpec) Benchmark(b *testing.B)
  • func (spec DeleterPublisherSpec) Spec(s *testcase.Spec)
  • func (spec DeleterPublisherSpec) Test(t *testing.T)
• type DeleterSpec
  • func (spec DeleterSpec) Benchmark(b *testing.B)
  • func (spec DeleterSpec) Test(t *testing.T)
• type FinderSpec
  • func (spec FinderSpec) Benchmark(b *testing.B)
  • func (spec FinderSpec) Test(t *testing.T)
• type FixtureFactory
• type FixtureFactorySpec
  • func (spec FixtureFactorySpec) Test(t *testing.T)
• type OnePhaseCommitProtocolSpec
  • func (spec OnePhaseCommitProtocolSpec) Benchmark(b *testing.B)
  • func (spec OnePhaseCommitProtocolSpec) Spec(tb testing.TB)
  • func (spec OnePhaseCommitProtocolSpec) Test(t *testing.T)
• type UniqConstrainSpec
  • func (spec UniqConstrainSpec) Benchmark(b *testing.B)
  • func (spec UniqConstrainSpec) Test(t *testing.T)
• type UpdaterPublisherSpec
  • func (spec UpdaterPublisherSpec) Benchmark(b *testing.B)
  • func (spec UpdaterPublisherSpec) Spec(s *testcase.Spec)
  • func (spec UpdaterPublisherSpec) Test(t *testing.T)
• type UpdaterSpec
  • func (spec UpdaterSpec) Benchmark(b *testing.B)
  • func (spec UpdaterSpec) Test(t *testing.T)

Constants

const ErrIDRequired frameless.Error = `` /* 174-byte string literal not displayed */

Functions

func BenchmarkEntityVolumeCount

func BenchmarkEntityVolumeCount() int

func TestUniqConstrain

func TestUniqConstrain(t *testing.T, r minimumRequirements, e interface{}, f FixtureFactory, uniqConstrain ...string)

Types

type CommonSpec

type CommonSpec struct {
	EntityType interface{}
	FixtureFactory
	Subject interface {
		resources.Updater
		// contains filtered or unexported methods
	}
}

func (CommonSpec) Benchmark

func (spec CommonSpec) Benchmark(b *testing.B)

func (CommonSpec) Test

func (spec CommonSpec) Test(t *testing.T)

type CreatorPublisherSpec

type CreatorPublisherSpec struct {
	Subject interface {
		resources.CreatorPublisher
		// contains filtered or unexported methods
	}
	EntityType     interface{}
	FixtureFactory FixtureFactory
}

func (CreatorPublisherSpec) Benchmark

func (spec CreatorPublisherSpec) Benchmark(b *testing.B)

func (CreatorPublisherSpec) Spec

func (spec CreatorPublisherSpec) Spec(s *testcase.Spec)

func (CreatorPublisherSpec) Test

func (spec CreatorPublisherSpec) Test(t *testing.T)

type CreatorSpec

type CreatorSpec struct {
	EntityType interface{}
	FixtureFactory
	Subject minimumRequirements
}

func (CreatorSpec) Benchmark

func (spec CreatorSpec) Benchmark(b *testing.B)

func (CreatorSpec) Test

func (spec CreatorSpec) Test(t *testing.T)

type DeleterPublisherSpec

type DeleterPublisherSpec struct {
	Subject interface {
		resources.DeleterPublisher
		// contains filtered or unexported methods
	}
	EntityType     interface{}
	FixtureFactory FixtureFactory
}

func (DeleterPublisherSpec) Benchmark

func (spec DeleterPublisherSpec) Benchmark(b *testing.B)

func (DeleterPublisherSpec) Spec

func (spec DeleterPublisherSpec) Spec(s *testcase.Spec)

func (DeleterPublisherSpec) Test

func (spec DeleterPublisherSpec) Test(t *testing.T)

type DeleterSpec

type DeleterSpec struct {
	EntityType interface{}
	FixtureFactory
	Subject minimumRequirements
}

func (DeleterSpec) Benchmark

func (spec DeleterSpec) Benchmark(b *testing.B)

func (DeleterSpec) Test

func (spec DeleterSpec) Test(t *testing.T)

type FinderSpec

type FinderSpec struct {
	EntityType interface{}
	FixtureFactory
	Subject minimumRequirements
}

func (FinderSpec) Benchmark

func (spec FinderSpec) Benchmark(b *testing.B)

func (FinderSpec) Test

func (spec FinderSpec) Test(t *testing.T)

type FixtureFactory

type FixtureFactory interface {
	// Create create a newEntityBasedOn struct instance based on the received input struct type.
	// Create also populate the struct field with dummy values.
	// It is expected that the newly created fixture will have no content for extID field.
	Create(EntityType interface{}) (StructPTR interface{})
	// Context able to provide the specs with a context object for a certain entity Type.
	Context() (ctx context.Context)
}

type FixtureFactorySpec

type FixtureFactorySpec struct {
	Type interface{}
	FixtureFactory
}

func (FixtureFactorySpec) Test

func (spec FixtureFactorySpec) Test(t *testing.T)

type OnePhaseCommitProtocolSpec

type OnePhaseCommitProtocolSpec struct {
	EntityType     interface{}
	FixtureFactory FixtureFactory
	Subject        interface {
		resources.OnePhaseCommitProtocol
		// contains filtered or unexported methods
	}
}

func (OnePhaseCommitProtocolSpec) Benchmark

func (spec OnePhaseCommitProtocolSpec) Benchmark(b *testing.B)

func (OnePhaseCommitProtocolSpec) Spec

func (spec OnePhaseCommitProtocolSpec) Spec(tb testing.TB)

func (OnePhaseCommitProtocolSpec) Test

func (spec OnePhaseCommitProtocolSpec) Test(t *testing.T)

type UniqConstrainSpec

type UniqConstrainSpec struct {
	// Struct that is the subject of this spec
	EntityType interface{}
	FixtureFactory

	// the combination of which the values must be uniq
	// The values for this are the struct Fields that together represent a uniq constrain
	// if you only want to make uniq one certain field across the Resource,
	// then you only have to provide that only value in the slice
	UniqConstrain []string

	// the Resource object that implements the specification
	Subject minimumRequirements
}

func (UniqConstrainSpec) Benchmark

func (spec UniqConstrainSpec) Benchmark(b *testing.B)

func (UniqConstrainSpec) Test

func (spec UniqConstrainSpec) Test(t *testing.T)

type UpdaterPublisherSpec

type UpdaterPublisherSpec struct {
	Subject interface {
		resources.Updater
		resources.UpdaterPublisher
		// contains filtered or unexported methods
	}
	EntityType     interface{}
	FixtureFactory FixtureFactory
}

func (UpdaterPublisherSpec) Benchmark

func (spec UpdaterPublisherSpec) Benchmark(b *testing.B)

func (UpdaterPublisherSpec) Spec

func (spec UpdaterPublisherSpec) Spec(s *testcase.Spec)

func (UpdaterPublisherSpec) Test

func (spec UpdaterPublisherSpec) Test(t *testing.T)

type UpdaterSpec

type UpdaterSpec struct {
	EntityType interface{}
	FixtureFactory
	Subject updateSpecSubject
}

UpdaterSpec will request an update for a wrapped entity object in the Resource

func (UpdaterSpec) Benchmark

func (spec UpdaterSpec) Benchmark(b *testing.B)

func (UpdaterSpec) Test

func (spec UpdaterSpec) Test(t *testing.T)