Synnefo » snf-ganeti

import Test.HUnit

import qualified Data.Graph as Graph

import Test.Ganeti.HTools.Instance ( genInstanceSmallerThanNode

                                   , genInstanceList

                                   , genInstanceOnNodeList)

import qualified Ganeti.HTools.Graph as HGraph

{-# ANN module "HLint: ignore Use camelCase" #-}

-- | Generate a node list, an instance list, and a node graph.

-- We choose instances with nodes contained in the node list.

genNodeGraph :: Gen (Maybe Graph.Graph, Node.List, Instance.List)

genNodeGraph = do

  nl <- genNodeList genOnlineNode `suchThat` ((2<=).Container.size)

  il <- genInstanceList (genInstanceOnNodeList nl)

  return (Node.mkNodeGraph nl il, nl, il)

-- | Check that no graph is created on an empty node list.

case_emptyNodeList :: Assertion

case_emptyNodeList =

  assertEqual "" Nothing $ Node.mkNodeGraph emptynodes emptyinstances

    where emptynodes = Container.empty :: Node.List

          emptyinstances = Container.empty :: Instance.List

-- | Check that the number of vertices of a nodegraph is equal to the number of

-- nodes in the original node list.

prop_numVertices :: Property

prop_numVertices =

  forAll genNodeGraph $ \(graph, nl, _) ->

    (fmap numvertices graph ==? Just (Container.size nl))

    where numvertices = length . Graph.vertices

-- | Check that the number of edges of a nodegraph is equal to twice the number

-- of instances with secondary nodes in the original instance list.

prop_numEdges :: Property

prop_numEdges =

  forAll genNodeGraph $ \(graph, _, il) ->

    (fmap numedges graph ==? Just (numwithsec il * 2))

    where numedges = length . Graph.edges

          numwithsec = length . filter Instance.hasSecondary . Container.elems

-- | Check that a node graph is colorable.

prop_nodeGraphIsColorable :: Property

prop_nodeGraphIsColorable =

  forAll genNodeGraph $ \(graph, _, _) ->

    fmap HGraph.isColorable graph ==? Just True

-- | Check that each edge in a nodegraph is an instance.

prop_instanceIsEdge :: Property

prop_instanceIsEdge =

  forAll genNodeGraph $ \(graph, _, il) ->

    fmap (\g -> all (`isEdgeOn` g) (iwithsec il)) graph ==? Just True

    where i `isEdgeOn` g = iEdges i `intersect` Graph.edges g == iEdges i

          iEdges i = [ (Instance.pNode i, Instance.sNode i)

                     , (Instance.sNode i, Instance.pNode i)]

          iwithsec = filter Instance.hasSecondary . Container.elems

-- | Check that each instance in an edge in the resulting nodegraph.

prop_edgeIsInstance :: Property

prop_edgeIsInstance =

  forAll genNodeGraph $ \(graph, _, il) ->

    fmap (all (`isInstanceIn` il).Graph.edges) graph ==? Just True

      where e `isInstanceIn` il = any (`hasNodes` e) (Container.elems il)

            i `hasNodes` (v1,v2) =

              Instance.allNodes i `elem` permutations [v1,v2]

-- | List of tests for the Node module.

            , 'case_emptyNodeList

            , 'prop_numVertices

            , 'prop_numEdges

            , 'prop_nodeGraphIsColorable

            , 'prop_edgeIsInstance

            , 'prop_instanceIsEdge