Synnefo » snf-ganeti » ganeti-local

             show x ++ "' /= '" ++ show y ++ "'") (x == y)

infix 3 ==?

-- | Update an instance to be smaller than a node.

setInstanceSmallerThanNode node inst =

  inst { Instance.mem = Node.availMem node `div` 2

               , snode::String

               , autobal::Bool)

  in case inst of

       Types.Ok (_, i) -> printTestCase "Mismatch in some field while\

                                        \ loading the instance" $

               Instance.name i == name &&

prop_Text_Load_InstanceFail ktn fields =

  length fields /= 10 ==>

    case Text.loadInst nl fields of

      Types.Bad msg -> printTestCase ("Unrecognised error message: " ++ msg) $

                       "Invalid/incomplete instance data: '" `isPrefixOf` msg

    where nl = Data.Map.fromList ktn

prop_Text_ISpecIdempotent ispec =

  case Text.loadISpec "dummy" . Utils.sepSplit ',' .

       Text.serializeISpec $ ispec of

    Types.Ok ispec' -> ispec ==? ispec'

prop_Text_IPolicyIdempotent ipol =

  case Text.loadIPolicy . Utils.sepSplit '|' $

       Text.serializeIPolicy owner ipol of

    Types.Ok res -> (owner, ipol) ==? res

  where owner = "dummy"

  in case Cluster.genAllocNodes defGroupList nl reqnodes True >>= \allocn ->

     Cluster.iterateAlloc nl Container.empty (Just maxiter) inst' allocn [] []

     of

       Types.Ok (_, _, _, [], _) -> printTestCase

                                    "Failed to allocate: no allocations" False

       Types.Ok (_, nl', il', _, _) ->

                     Types.defIPolicy

             saved = Text.serializeCluster cdata

         in case Text.parseData saved >>= Loader.mergeData [] [] [] [] of

              Types.Ok (Loader.ClusterData gl2 nl2 il2 ctags2 cpol2) ->

                ctags ==? ctags2 .&&.

                Types.defIPolicy ==? cpol2 .&&.

           -- test as any

           inst_idx `elem` Node.sList a_ab &&

           inst_idx `notElem` Node.sList d_ab

-- | Check mdsk setting.

prop_Node_setMdsk node mx =

      i_templ = createInstance Types.unitMem Types.unitDsk Types.unitCpu

  in case allocnodes >>= \allocnodes' ->

    Cluster.iterateAlloc nl' il (Just 5) i_templ allocnodes' [] [] of

       Types.Ok (_, xnl, il', _, _) ->

         let ynl = Container.add (Node.idx hnode) hnode xnl

             cv = Cluster.compCV ynl

-- | Check that opcode serialization is idempotent.

prop_OpCodes_serialization op =

  case J.readJSON (J.showJSON op) of

    J.Ok op' -> op ==? op'

  where _types = op::OpCodes.OpCode

-- | Check that (queued) job\/opcode status serialization is idempotent.

prop_OpStatus_serialization os =

  case J.readJSON (J.showJSON os) of

    J.Ok os' -> os ==? os'

  where _types = os::Jobs.OpStatus

prop_JobStatus_serialization js =

  case J.readJSON (J.showJSON js) of

    J.Ok js' -> js ==? js'

  where _types = js::Jobs.JobStatus

prop_Types_AllocPolicy_serialisation apol =

  case J.readJSON (J.showJSON apol) of

    J.Ok p -> p ==? apol

      where _types = apol::Types.AllocPolicy

prop_Types_DiskTemplate_serialisation dt =

  case J.readJSON (J.showJSON dt) of

    J.Ok p -> p ==? dt

      where _types = dt::Types.DiskTemplate

prop_Types_ISpec_serialisation ispec =

  case J.readJSON (J.showJSON ispec) of

    J.Ok p -> p ==? ispec

      where _types = ispec::Types.ISpec

prop_Types_IPolicy_serialisation ipol =

  case J.readJSON (J.showJSON ipol) of

    J.Ok p -> p ==? ipol

      where _types = ipol::Types.IPolicy

prop_Types_EvacMode_serialisation em =

  case J.readJSON (J.showJSON em) of

    J.Ok p -> p ==? em

      where _types = em::Types.EvacMode

prop_Types_opToResult op =