Test.Serialization.Symbiote.Core

This module defines the machinery of any topic's state machine:

• agnostic for whatever type or operation you're testing
• doesn't try to define the stuff that orchestrates multiple topics operating together
• doesn't specify how the protocol actually looks with respect to the messages sent between the peers

Documentation

class SymbioteOperation a o | a -> o where

A type-level relation between a type and appropriate, testable operations on that type.

Associated Types

data Operation a :: *

An enumerated type of operations on a that result in o.

Methods

perform :: Operation a -> a -> o

Apply the Operation to a, to get an o.

Instances

(Fractional a, Eq a) => SymbioteOperation (AbidesField a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesField a) :: Type

Methods

perform :: Operation (AbidesField a) -> AbidesField a -> Bool

(Num a, Eq a) => SymbioteOperation (AbidesEuclideanRing a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesEuclideanRing a) :: Type

Methods

perform :: Operation (AbidesEuclideanRing a) -> AbidesEuclideanRing a -> Bool

(Fractional a, Eq a) => SymbioteOperation (AbidesDivisionRing a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesDivisionRing a) :: Type

Methods

perform :: Operation (AbidesDivisionRing a) -> AbidesDivisionRing a -> Bool

(Num a, Eq a) => SymbioteOperation (AbidesCommutativeRing a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesCommutativeRing a) :: Type

Methods

perform :: Operation (AbidesCommutativeRing a) -> AbidesCommutativeRing a -> Bool

(Num a, Eq a) => SymbioteOperation (AbidesRing a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesRing a) :: Type

Methods

perform :: Operation (AbidesRing a) -> AbidesRing a -> Bool

(Num a, Eq a) => SymbioteOperation (AbidesSemiring a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesSemiring a) :: Type

Methods

perform :: Operation (AbidesSemiring a) -> AbidesSemiring a -> Bool

(Enum a, Ord a) => SymbioteOperation (AbidesEnum a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesEnum a) :: Type

Methods

perform :: Operation (AbidesEnum a) -> AbidesEnum a -> Bool

Ord a => SymbioteOperation (AbidesOrd a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesOrd a) :: Type

Methods

perform :: Operation (AbidesOrd a) -> AbidesOrd a -> Bool

Eq a => SymbioteOperation (AbidesEq a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesEq a) :: Type

Methods

perform :: Operation (AbidesEq a) -> AbidesEq a -> Bool

(Monoid a, Eq a) => SymbioteOperation (AbidesMonoid a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesMonoid a) :: Type

Methods

perform :: Operation (AbidesMonoid a) -> AbidesMonoid a -> Bool

(Semigroup a, Eq a) => SymbioteOperation (AbidesSemigroup a) Bool

Defined in Test.Serialization.Symbiote.Abides

Associated Types

data Operation (AbidesSemigroup a) :: Type

Methods

perform :: Operation (AbidesSemigroup a) -> AbidesSemigroup a -> Bool

class SymbioteOperation a o => Symbiote a o s | a -> o where

A serialization format for a particular type, and serialized data type.

Methods

encode :: a -> s

decode :: s -> Maybe a

encodeOut :: Proxy a -> o -> s

Needs a reference to a because the fundep is only one direction (i.e. only one output defined per input, but could be used elsewhere)

decodeOut :: Proxy a -> s -> Maybe o

Needs a reference to a because the fundep is only one direction

encodeOp :: Operation a -> s

decodeOp :: s -> Maybe (Operation a)

Instances

(Serialize a, Serialize o, Serialize (Operation a), SymbioteOperation a o) => Symbiote a o ByteString

Defined in Test.Serialization.Symbiote.Cereal.Lazy

Methods

encode :: a -> ByteString

decode :: ByteString -> Maybe a

encodeOut :: Proxy a -> o -> ByteString

decodeOut :: Proxy a -> ByteString -> Maybe o

encodeOp :: Operation a -> ByteString

decodeOp :: ByteString -> Maybe (Operation a)

(Serialize a, Serialize o, Serialize (Operation a), SymbioteOperation a o) => Symbiote a o ByteString

Defined in Test.Serialization.Symbiote.Cereal

Methods

encode :: a -> ByteString

decode :: ByteString -> Maybe a

encodeOut :: Proxy a -> o -> ByteString

decodeOut :: Proxy a -> ByteString -> Maybe o

encodeOp :: Operation a -> ByteString

decodeOp :: ByteString -> Maybe (Operation a)

(ToJSON a, FromJSON a, ToJSON o, FromJSON o, ToJSON (Operation a), FromJSON (Operation a), SymbioteOperation a o) => Symbiote a o Value

Defined in Test.Serialization.Symbiote.Aeson

Methods

encode :: a -> Value

decode :: Value -> Maybe a

encodeOut :: Proxy a -> o -> Value

decodeOut :: Proxy a -> Value -> Maybe o

encodeOp :: Operation a -> Value

decodeOp :: Value -> Maybe (Operation a)

SymbioteOperation a o => Symbiote a o (SimpleSerialization a o)

Defined in Test.Serialization.Symbiote

Methods

encode :: a -> SimpleSerialization a o

decode :: SimpleSerialization a o -> Maybe a

encodeOut :: Proxy a -> o -> SimpleSerialization a o

decodeOut :: Proxy a -> SimpleSerialization a o -> Maybe o

encodeOp :: Operation a -> SimpleSerialization a o

decodeOp :: SimpleSerialization a o -> Maybe (Operation a)

newtype Topic

Unique name of a type, for a suite of tests. Ref - Topic.

Constructors

Topic Text

Instances

Eq Topic

Defined in Test.Serialization.Symbiote.Core

Methods

(==) :: Topic -> Topic -> Bool

(/=) :: Topic -> Topic -> Bool

Ord Topic

Defined in Test.Serialization.Symbiote.Core

Methods

compare :: Topic -> Topic -> Ordering

(<) :: Topic -> Topic -> Bool

(<=) :: Topic -> Topic -> Bool

(>) :: Topic -> Topic -> Bool

(>=) :: Topic -> Topic -> Bool

max :: Topic -> Topic -> Topic

min :: Topic -> Topic -> Topic

Show Topic

Defined in Test.Serialization.Symbiote.Core

Methods

showsPrec :: Int -> Topic -> ShowS

show :: Topic -> String

showList :: [Topic] -> ShowS

IsString Topic

Defined in Test.Serialization.Symbiote.Core

Methods

fromString :: String -> Topic

Arbitrary Topic

Defined in Test.Serialization.Symbiote.Core

Methods

arbitrary :: Gen Topic

shrink :: Topic -> [Topic]

ToJSON Topic

Defined in Test.Serialization.Symbiote.Core

Methods

toJSON :: Topic -> Value

toEncoding :: Topic -> Encoding

toJSONList :: [Topic] -> Value

toEncodingList :: [Topic] -> Encoding

ToJSONKey Topic

Defined in Test.Serialization.Symbiote.Core

Methods

toJSONKey :: ToJSONKeyFunction Topic

toJSONKeyList :: ToJSONKeyFunction [Topic]

FromJSON Topic

Defined in Test.Serialization.Symbiote.Core

Methods

parseJSON :: Value -> Parser Topic

parseJSONList :: Value -> Parser [Topic]

FromJSONKey Topic

Defined in Test.Serialization.Symbiote.Core

Methods

fromJSONKey :: FromJSONKeyFunction Topic

fromJSONKeyList :: FromJSONKeyFunction [Topic]

Serialize Topic

Serialized as a String32 in the symbiotic-data standard.

Defined in Test.Serialization.Symbiote.Core

Methods

put :: Putter Topic

get :: Get Topic

data SymbioteProtocol a s

The state-machine representation for a particular topic, identical for each peer. As the protocol progresses and messages are passed, and values are generated, this value will change over time, and is unique for each topic.

Constructors

MeGenerated

"I'm generating a value"

Fields

• meGenValue :: a

  The value generated

• meGenOperation :: Operation a

  The operation generated

• meGenReceived :: Maybe s

  Remotely operated value - might not exist due to the need for the remote party to send the o output value.

ThemGenerating

"They're generating a value"

Fields

• themGen :: Maybe (s, s)

  Remotely generated value and operation - might not exist due to the need for the remote party to send the a and Operation values.

NotStarted

The topic's generation / operation exchange hasn't started for either peer

Finished

The topic's generation / operation exchange has completed, and is currently being processed on another topic, or the whole suite is finished for all topics.

data SymbioteGeneration a s

Protocol state, with amended "current generation value" information

Constructors

SymbioteGeneration

Fields

• size :: Int32

  The current "size" for the generated values and operations, with respect to QuickCheck's size parameter.

• protocol :: SymbioteProtocol a s

  The rest of the state

newGeneration :: SymbioteGeneration a s

The initial state for any topic's state machine.

data SymbioteState a o s

Internal existential state of a registered topic, with fields explicitly storing a type's normally typeclass-specified facilities.

Constructors

SymbioteState

Fields

• generate :: Gen a

  Generate a random value

• generateOp :: Gen (Operation a)

  Generate a random operation

• equal :: o -> o -> Bool

  Are the outputs equal?

• maxSize :: Int32

  Maximum size the internal generation will approach to - with respect to QuickCheck's size parameter

• generation :: TVar (SymbioteGeneration a s)

  The actual state of the topic, stored as an atomically modifiable TVar

• encode' :: a -> s

  encode

• encodeOut' :: o -> s

  encodeOut

• encodeOp' :: Operation a -> s

  encodeOp

• decode' :: s -> Maybe a

  decode

• decodeOut' :: s -> Maybe o

  decodeOut

• decodeOp' :: s -> Maybe (Operation a)

  decodeOp

• perform' :: Operation a -> a -> o

  perform

data ExistsSymbiote s

A custom existential quantifier, which places additional typeclass constraints on the a and o variables of SymbioteState, leaving only s as the globally visible type variable - the "serialization" medium.

Constructors

(Arbitrary a, Arbitrary (Operation a), Symbiote a o s, Eq o) => ExistsSymbiote (SymbioteState a o s)

type SymbioteT s m = ReaderT Bool (StateT (Map Topic (ExistsSymbiote s)) m)

Builder for the total set of topics supported by this peer.

runSymbioteT

Arguments

:: Monad m

=> SymbioteT s m ()

-> Bool

Is this the first peer to initiate the protocol?

-> m (Map Topic (ExistsSymbiote s))

Get the set of topics from the builder.

data GenerateSymbiote s

Used internally - attempt generating a value and operation for a specific topic, by using the mechanics defined in the protocol's stored state and existential typeclass facilities.

Constructors

DoneGenerating

Can't generate any more values, and "is finished"

GeneratedSymbiote

Generated a value and operation, as serialized values

Fields

• generatedValue :: s
• generatedOperation :: s

generateSymbiote :: forall s m. MonadIO m => ExistsSymbiote s -> m (GenerateSymbiote s)

Given an existentially stored topic state, attempt to generate a value and operation for that topic's type.

getProgress :: MonadIO m => ExistsSymbiote s -> m Float

The current "progress" or "percent complete" of the topic - the current size divided by the maxSize.