diff --git a/ocaml/tests/suite.ml b/ocaml/tests/suite.ml index 6c07e2e194f..cf1d62a1c07 100644 --- a/ocaml/tests/suite.ml +++ b/ocaml/tests/suite.ml @@ -20,24 +20,18 @@ let base_suite = Test_helpers.test; Test_datamodel_utils.test; Test_http.test; - Test_pool_db_backup.test; - Test_xapi_db_upgrade.test; Test_ha_vm_failover.test; Test_map_check.test; Test_pool_license.test; Test_features.test; - Test_pool_restore_database.test; Test_platformdata.test; Test_sm_features.test; - Test_pci_helpers.test; Test_vgpu_type.test; - Test_pgpu.test; Test_pgpu_helpers.test; Test_storage_migrate_state.test; Test_vm.test; Test_vm_helpers.test; Test_xenopsd_metadata.test; - Test_workload_balancing.test; Test_cpuid_helpers.test; Test_pool_cpuinfo.test; (* Test_ca121350.test; *) @@ -53,7 +47,6 @@ let base_suite = Test_network_sriov.test; Test_xapi_vbd_helpers.test; Test_sr_update_vdis.test; - Test_network.test; Test_host_helpers.test; ] diff --git a/ocaml/tests/suite_alcotest.ml b/ocaml/tests/suite_alcotest.ml index 7f6670dfb26..9a1780459e1 100644 --- a/ocaml/tests/suite_alcotest.ml +++ b/ocaml/tests/suite_alcotest.ml @@ -7,23 +7,30 @@ let () = Alcotest.run "Base suite" [ "Test_valid_ref_list", Test_valid_ref_list.test + ; "Test_pci_helpers", Test_pci_helpers.test ; "Test_vdi_allowed_operations", Test_vdi_allowed_operations.test ; "Test_vm_migrate", Test_vm_migrate.test ; "Test_no_migrate", Test_no_migrate.test ; "Test_vm_check_operation_error", Test_vm_check_operation_error.test ; "Test_host", Test_host.test ; "Test_vdi_cbt", Test_vdi_cbt.test + ; "Test_xapi_db_upgrade", Test_xapi_db_upgrade.test ; "Test_db_lowlevel", Test_db_lowlevel.test ; "Test_vlan", Test_vlan.test + ; "Test_network", Test_network.test ; "Test_agility", Test_agility.test ; "Test_daemon_manager", Test_daemon_manager.test ; "Test_cluster", Test_cluster.test ; "Test_cluster_host", Test_cluster_host.test ; "Test_client", Test_client.test ; "Test_ca91480", Test_ca91480.test + ; "Test_pgpu", Test_pgpu.test ; "Test_gpu_group", Test_gpu_group.test ; "Test_pool_apply_edition", Test_pool_apply_edition.test ; "Test_pool_update", Test_pool_update.test + ; "Test_pool_db_backup", Test_pool_db_backup.test + ; "Test_pool_restore_database", Test_pool_restore_database.test + ; "Test_workload_balancing", Test_workload_balancing.test ; "Test_pusb", Test_pusb.test ; "Test_pvs_site", Test_pvs_site.test ; "Test_pvs_proxy", Test_pvs_proxy.test diff --git a/ocaml/tests/test_network.ml b/ocaml/tests/test_network.ml index fe9e8043d20..191cccfb11c 100644 --- a/ocaml/tests/test_network.ml +++ b/ocaml/tests/test_network.ml @@ -1,138 +1,132 @@ -let test_purpose_setters = - let assert_equal ~msg p1 p2 = Ounit_comparators.NetworkPurposeSet.(assert_equal ~msg (of_list p1) (of_list p2)) in - - let with_test f = - let __context = Mock.make_context_with_new_db "Mock context" in - let network ~purpose = Test_common.make_network ~__context ~purpose () in - let add_purpose = Xapi_network.add_purpose ~__context in - let remove_purpose = Xapi_network.remove_purpose ~__context in - let get_purpose = Db.Network.get_purpose ~__context in - f network add_purpose remove_purpose get_purpose - in - - let test_add_purpose () = - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[] in - add_purpose ~self:network1 ~value:`nbd; - assert_equal - ~msg:"Should be able to add 'nbd' purpose when none of the networks have a purpose" - [`nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[`nbd] in - add_purpose ~self:network1 ~value:`nbd; - assert_equal - ~msg:"Should be able to add 'nbd' purpose when the other network has the same purpose" - [`nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[] in - add_purpose ~self:network1 ~value:`insecure_nbd; - assert_equal - ~msg:"Should be able to add 'insecure_nbd' purpose when none of the networks have a purpose" - [`insecure_nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[`insecure_nbd] in - add_purpose ~self:network1 ~value:`insecure_nbd; - assert_equal - ~msg:"Should be able to add 'insecure_nbd' purpose when the other network has the same purpose" - [`insecure_nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[`nbd] in - add_purpose ~self:network1 ~value:`nbd; - assert_equal - ~msg:"add_purpose should be idempotent and should do nothing when adding an existing purpose" - [`nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[`nbd] in - OUnit.assert_raises - ~msg:"Should not be allowed to add 'insecure_nbd' to a network that already has the 'nbd' purpose" - (* The first parameter of this error is the new purpose we're trying to add, the second is the conflicting one. *) - Api_errors.(Server_error (network_incompatible_purposes, ["insecure_nbd"; "nbd"])) - (fun () -> add_purpose ~self:network1 ~value:`insecure_nbd); - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[`nbd] in - OUnit.assert_raises - ~msg:"Should not be allowed to add 'insecure_nbd' when another network already has the 'nbd' purpose" - Api_errors.(Server_error (network_incompatible_purposes, ["insecure_nbd"; "nbd"])) - (fun () -> add_purpose ~self:network1 ~value:`insecure_nbd); - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[`insecure_nbd] in - OUnit.assert_raises - ~msg:"Should not be allowed to add 'nbd' to a network that already has the 'insecure_nbd' purpose" - Api_errors.(Server_error (network_incompatible_purposes, ["nbd"; "insecure_nbd"])) - (fun () -> add_purpose ~self:network1 ~value:`nbd); - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - let _network2 : _ API.Ref.t = network ~purpose:[`insecure_nbd] in - OUnit.assert_raises - ~msg:"Should not be allowed to add 'nbd' when another network already has the 'insecure_nbd' purpose" - Api_errors.(Server_error (network_incompatible_purposes, ["nbd"; "insecure_nbd"])) - (fun () -> add_purpose ~self:network1 ~value:`nbd); - ) - in - - let test_remove_purpose () = - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[`nbd] in - remove_purpose ~self:network1 ~value:`insecure_nbd; - assert_equal - ~msg:"remove_purpose should be idempotent and should do nothing when removing an invalid purpose that is not present" - [`nbd] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[] in - remove_purpose ~self:network1 ~value:`nbd; - assert_equal - ~msg:"remove_purpose should be idempotent and should do nothing when removing a valid purpose that isn't present" - [] - (get_purpose ~self:network1) - ); - - with_test (fun network add_purpose remove_purpose get_purpose -> - let network1 = network ~purpose:[`nbd] in - remove_purpose ~self:network1 ~value:`nbd; - assert_equal - ~msg:"remove_purpose should successfully remove a purpose that is present" - [] - (get_purpose ~self:network1) - ) - in - - let ((>:::), (>::)) = OUnit.((>:::), (>::)) in - "test_purpose_setters" >::: - [ "test_add_purpose" >:: test_add_purpose - ; "test_remove_purpose" >:: test_remove_purpose - ] +let assert_equal msg p1 p2 = + let network_purpose = Alcotest_comparators.from_rpc_of_t API.rpc_of_network_purpose in + Alcotest.(check (slist network_purpose compare)) + msg + p1 p2 + +let with_test f = + let __context = Mock.make_context_with_new_db "Mock context" in + let network ~purpose = Test_common.make_network ~__context ~purpose () in + let add_purpose = Xapi_network.add_purpose ~__context in + let remove_purpose = Xapi_network.remove_purpose ~__context in + let get_purpose = Db.Network.get_purpose ~__context in + f network add_purpose remove_purpose get_purpose + +let test_add_purpose () = + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[] in + add_purpose ~self:network1 ~value:`nbd; + assert_equal + "Should be able to add 'nbd' purpose when none of the networks have a purpose" + [`nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[`nbd] in + add_purpose ~self:network1 ~value:`nbd; + assert_equal + "Should be able to add 'nbd' purpose when the other network has the same purpose" + [`nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[] in + add_purpose ~self:network1 ~value:`insecure_nbd; + assert_equal + "Should be able to add 'insecure_nbd' purpose when none of the networks have a purpose" + [`insecure_nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[`insecure_nbd] in + add_purpose ~self:network1 ~value:`insecure_nbd; + assert_equal + "Should be able to add 'insecure_nbd' purpose when the other network has the same purpose" + [`insecure_nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[`nbd] in + add_purpose ~self:network1 ~value:`nbd; + assert_equal + "add_purpose should be idempotent and should do nothing when adding an existing purpose" + [`nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[`nbd] in + Alcotest.check_raises + "Should not be allowed to add 'insecure_nbd' to a network that already has the 'nbd' purpose" + (* The first parameter of this error is the new purpose we're trying to add, the second is the conflicting one. *) + Api_errors.(Server_error (network_incompatible_purposes, ["insecure_nbd"; "nbd"])) + (fun () -> add_purpose ~self:network1 ~value:`insecure_nbd); + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[`nbd] in + Alcotest.check_raises + "Should not be allowed to add 'insecure_nbd' when another network already has the 'nbd' purpose" + Api_errors.(Server_error (network_incompatible_purposes, ["insecure_nbd"; "nbd"])) + (fun () -> add_purpose ~self:network1 ~value:`insecure_nbd); + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[`insecure_nbd] in + Alcotest.check_raises + "Should not be allowed to add 'nbd' to a network that already has the 'insecure_nbd' purpose" + Api_errors.(Server_error (network_incompatible_purposes, ["nbd"; "insecure_nbd"])) + (fun () -> add_purpose ~self:network1 ~value:`nbd); + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + let _network2 : _ API.Ref.t = network ~purpose:[`insecure_nbd] in + Alcotest.check_raises + "Should not be allowed to add 'nbd' when another network already has the 'insecure_nbd' purpose" + Api_errors.(Server_error (network_incompatible_purposes, ["nbd"; "insecure_nbd"])) + (fun () -> add_purpose ~self:network1 ~value:`nbd); + ) + +let test_remove_purpose () = + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[`nbd] in + remove_purpose ~self:network1 ~value:`insecure_nbd; + assert_equal + "remove_purpose should be idempotent and should do nothing when removing an invalid purpose that is not present" + [`nbd] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[] in + remove_purpose ~self:network1 ~value:`nbd; + assert_equal + "remove_purpose should be idempotent and should do nothing when removing a valid purpose that isn't present" + [] + (get_purpose ~self:network1) + ); + + with_test (fun network add_purpose remove_purpose get_purpose -> + let network1 = network ~purpose:[`nbd] in + remove_purpose ~self:network1 ~value:`nbd; + assert_equal + "remove_purpose should successfully remove a purpose that is present" + [] + (get_purpose ~self:network1) + ) let test = - let ((>:::), (>::)) = OUnit.((>:::), (>::)) in - "test_network" >::: - [ test_purpose_setters ] + [ "test_add_purpose", `Quick, test_add_purpose + ; "test_remove_purpose", `Quick, test_remove_purpose + ] diff --git a/ocaml/tests/test_pci_helpers.ml b/ocaml/tests/test_pci_helpers.ml index a829cd9711c..eeb360d1720 100644 --- a/ocaml/tests/test_pci_helpers.ml +++ b/ocaml/tests/test_pci_helpers.ml @@ -12,39 +12,35 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Xapi_pci_helpers -(* This test generates a lot of print --- set skip to false to enable *) -let skip = true +(* This test generates a lot of print which will now be output to a separate file *) -let print_host_pcis () = - skip_if skip "Generates lots of text..."; +let test_print_host_pcis () = try print_string "===== Host PCIs =====\n\n"; - let pcis = get_host_pcis () in - List.iter - (fun p -> - let x_to_str = Printf.sprintf "%04x" in - Printf.printf "%s " (String.concat " " - [ - p.address; - x_to_str p.vendor.id; - p.vendor.name; - x_to_str p.device.id; - p.device.name; - x_to_str p.pci_class.id; - p.pci_class.name - ]); - List.iter (fun s -> print_string (s ^ ", ")) p.related; - print_newline ()) - pcis + let pcis = Xapi_pci_helpers.get_host_pcis () in + Alcotest.(check unit) + "test_pci_helpers" + () + (List.iter + Xapi_pci_helpers.(fun p -> + let x_to_str = Printf.sprintf "%04x" in + Printf.printf "%s " (String.concat " " + [ + p.address; + x_to_str p.vendor.id; + p.vendor.name; + x_to_str p.device.id; + p.device.name; + x_to_str p.pci_class.id; + p.pci_class.name + ]); + List.iter (fun s -> print_string (s ^ ", ")) p.related; + print_newline ()) + pcis) with e -> - print_string (Printexc.to_string e); - assert_equal 0 1 + Alcotest.fail (Printexc.to_string e) let test = - "test_pci_helpers" >::: - [ - "print_host_pcis" >:: print_host_pcis; + [ "test_print_host_pcis", `Quick, test_print_host_pcis ] diff --git a/ocaml/tests/test_pgpu.ml b/ocaml/tests/test_pgpu.ml index fa128d632f6..330de160a17 100644 --- a/ocaml/tests/test_pgpu.ml +++ b/ocaml/tests/test_pgpu.ml @@ -12,58 +12,71 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Test_common -open Test_vgpu_common +module T = Test_common +module VGPU_T = Test_vgpu_common (*--- Helper functions ---*) let on_host_with_k2 (f : Context.t -> API.ref_PGPU -> 'a) = - let __context = make_test_database () in - let p = make_pgpu ~__context default_k2 in + let __context = T.make_test_database () in + let p = VGPU_T.(make_pgpu ~__context default_k2) in f __context p +let assert_raises_api_error msg expected_error f = + match (f ()) with + | exception Api_errors.(Server_error (actual_error,params)) -> + Alcotest.(check string) + msg + expected_error + actual_error + | _ -> Alcotest.fail msg + (*--- Xapi_pgpu.assert_can_run_VGPU tests ---*) let test_can_run_VGPU_succeeds_empty_pgpu () = on_host_with_k2 (fun __context p -> - let vgpu = make_vgpu ~__context k260q in + let vgpu = VGPU_T.(make_vgpu ~__context k260q) in Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu) let test_can_run_VGPU_succeeds_enabled_types () = on_host_with_k2 (fun __context p -> - let vgpus = List.map (make_vgpu ~__context) [k200; k240q; k260q] in + let vgpus = VGPU_T.(List.map (make_vgpu ~__context) [k200; k240q; k260q]) in ignore (List.map (fun vgpu -> Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu) vgpus)) let test_can_run_VGPU_succeeds_same_type () = on_host_with_k2 (fun __context p -> - let (_:API.ref_VGPU) = make_vgpu ~__context ~resident_on:p k260q in - let vgpu = make_vgpu ~__context k260q in + let (_:API.ref_VGPU) = VGPU_T.(make_vgpu ~__context ~resident_on:p k260q) in + let vgpu = VGPU_T.(make_vgpu ~__context k260q) in Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu) let test_can_run_VGPU_fails_unsupported_types () = on_host_with_k2 (fun __context p -> - let vgpus = List.map (make_vgpu ~__context) [k100; k140q] in + let vgpus = VGPU_T.(List.map (make_vgpu ~__context) [k100; k140q]) in ignore (List.map (fun vgpu -> - assert_raises_api_error Api_errors.vgpu_type_not_supported + assert_raises_api_error + "test_can_run_VGPU_fails_unsupported_types" + Api_errors.vgpu_type_not_supported (fun () -> Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu)) vgpus)) let test_can_run_VGPU_fails_disabled_type () = on_host_with_k2 (fun __context p -> - let vgpu = make_vgpu ~__context k200 in + let vgpu = VGPU_T.(make_vgpu ~__context k200) in let vgpu_type = Db.VGPU.get_type ~__context ~self:vgpu in Db.PGPU.remove_enabled_VGPU_types ~__context ~self:p ~value:vgpu_type; - assert_raises_api_error Api_errors.vgpu_type_not_enabled + assert_raises_api_error + "test_can_run_VGPU_fails_disabled_type" + Api_errors.vgpu_type_not_enabled (fun () -> Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu)) let test_can_run_VGPU_fails_different_type () = on_host_with_k2 (fun __context p -> - let (_:API.ref_VGPU) = make_vgpu ~__context ~resident_on:p k260q in - let vgpu = make_vgpu ~__context k240q in + let (_:API.ref_VGPU) = VGPU_T.(make_vgpu ~__context ~resident_on:p k260q) in + let vgpu = VGPU_T.(make_vgpu ~__context k240q) in assert_raises_api_error + "test_can_run_VGPU_fails_different_type" Api_errors.vgpu_type_not_compatible_with_running_type (fun () -> Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu)) @@ -71,10 +84,11 @@ let test_can_run_VGPU_fails_no_capacity () = on_host_with_k2 (fun __context p -> (* Fill up the pGPU with 2 x K260Q *) let (_:API.ref_VGPU list) = - List.map (make_vgpu ~__context ~resident_on:p) [k260q; k260q] in + VGPU_T.(List.map (make_vgpu ~__context ~resident_on:p) [k260q; k260q]) in (* Should fail to put another one on *) - let vgpu = make_vgpu ~__context k260q in + let vgpu = VGPU_T.(make_vgpu ~__context k260q) in assert_raises_api_error + "test_can_run_VGPU_fails_no_capacity" Api_errors.pgpu_insufficient_capacity_for_vgpu (fun () -> Xapi_pgpu.assert_can_run_VGPU ~__context ~self:p ~vgpu)) @@ -82,14 +96,16 @@ let test_can_run_VGPU_fails_no_capacity () = let check_capacity_is ~__context expected_capacity pgpu vgpu_type = let vgpu_type = Xapi_vgpu_type.find_or_create ~__context vgpu_type in - assert_equal ~printer:Int64.to_string expected_capacity + Alcotest.(check int64) + "check_capacity_is" + expected_capacity (Xapi_pgpu.get_remaining_capacity ~__context ~self:pgpu ~vgpu_type) -let expected_capacities = [(k200, 8L); (k240q, 4L); (k260q, 2L)] +let expected_capacities = VGPU_T.([(k200, 8L); (k240q, 4L); (k260q, 2L)]) let test_remaining_capacity_unsupported_types () = on_host_with_k2 (fun __context p -> - ignore (List.map (check_capacity_is ~__context 0L p) [k100; k140q])) + ignore (List.map (check_capacity_is ~__context 0L p) VGPU_T.([k100; k140q]))) let test_remaining_capacity_supported_types () = on_host_with_k2 (fun __context p -> @@ -101,13 +117,13 @@ let test_remaining_capacity_decreases () = let rec check_remaining_capacity_and_fill p c vgpu_type = check_capacity_is ~__context c p vgpu_type; if c > 0L then begin - ignore (make_vgpu ~__context ~resident_on:p vgpu_type); + ignore VGPU_T.(make_vgpu ~__context ~resident_on:p vgpu_type); check_remaining_capacity_and_fill p (Int64.sub c 1L) vgpu_type end in ignore (List.map (fun (vgpu_type, capacity) -> - let p = make_pgpu ~__context default_k2 in + let p = VGPU_T.(make_pgpu ~__context default_k2) in check_remaining_capacity_and_fill p capacity vgpu_type) expected_capacities)) @@ -115,47 +131,57 @@ let test_remaining_capacity_decreases () = let test_set_GPU_group_succeeds_empty_pgpu () = on_host_with_k2 (fun __context p -> - let group_ref = make_gpu_group ~__context () in + let group_ref = T.make_gpu_group ~__context () in Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group_ref) let test_set_GPU_group_succeeds_orphan_vgpu () = (* This is OK since vGPUs can be created on empty GPU groups *) on_host_with_k2 (fun __context p -> let group, group' = - (make_gpu_group ~__context (), make_gpu_group ~__context ()) + (T.make_gpu_group ~__context (), T.make_gpu_group ~__context ()) in Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group; let (_: API.ref_VGPU) = - Test_common.make_vgpu ~__context ~gPU_group:group () + T.make_vgpu ~__context ~gPU_group:group () in Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group') let test_set_GPU_group_fails_resident_vgpu () = on_host_with_k2 (fun __context p -> let group, group' = - (make_gpu_group ~__context (), make_gpu_group ~__context ()) + (T.make_gpu_group ~__context (), T.make_gpu_group ~__context ()) in Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group; - ignore (make_vgpu ~__context ~resident_on:p k200); - assert_raises_api_error Api_errors.pgpu_in_use_by_vm (fun () -> - Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group')) + ignore VGPU_T.(make_vgpu ~__context ~resident_on:p k200); + assert_raises_api_error + "test_set_GPU_group_fails_resident_vgpu" + Api_errors.pgpu_in_use_by_vm + (fun () -> Xapi_pgpu.set_GPU_group ~__context ~self:p ~value:group')) + +let test_can_run_vgpu = + [ "test_can_run_VGPU_succeeds_empty_pgpu", `Quick, test_can_run_VGPU_succeeds_empty_pgpu + ; "test_can_run_VGPU_succeeds_enabled_types", `Quick, test_can_run_VGPU_succeeds_enabled_types + ; "test_can_run_VGPU_succeeds_same_type", `Quick, test_can_run_VGPU_succeeds_same_type + ; "test_can_run_VGPU_fails_unsupported_types", `Quick, test_can_run_VGPU_fails_unsupported_types + ; "test_can_run_VGPU_fails_disabled_type", `Quick, test_can_run_VGPU_fails_disabled_type + ; "test_can_run_VGPU_fails_different_type", `Quick, test_can_run_VGPU_fails_different_type + ; "test_can_run_VGPU_fails_no_capacity", `Quick, test_can_run_VGPU_fails_no_capacity + ] -let test = - "test_pgpu" >::: - [ - "test_can_run_VGPU_succeeds_empty_pgpu" >:: test_can_run_VGPU_succeeds_empty_pgpu; - "test_can_run_VGPU_succeeds_enabled_types" >:: test_can_run_VGPU_succeeds_enabled_types; - "test_can_run_VGPU_succeeds_same_type" >:: test_can_run_VGPU_succeeds_same_type; - "test_can_run_VGPU_fails_unsupported_types" >:: test_can_run_VGPU_fails_unsupported_types; - "test_can_run_VGPU_fails_disabled_type" >:: test_can_run_VGPU_fails_disabled_type; - "test_can_run_VGPU_fails_different_type" >:: test_can_run_VGPU_fails_different_type; - "test_can_run_VGPU_fails_no_capacity" >:: test_can_run_VGPU_fails_no_capacity; - - "test_remaining_capacity_unsupported_types" >:: test_remaining_capacity_unsupported_types; - "test_remaining_capacity_supported_types" >:: test_remaining_capacity_supported_types; - "test_remaining_capacity_decreases" >:: test_remaining_capacity_decreases; - - "test_set_GPU_group_succeeds_empty_pgpu" >:: test_set_GPU_group_succeeds_empty_pgpu; - "test_set_GPU_group_succeeds_orphan_vgpu" >:: test_set_GPU_group_succeeds_orphan_vgpu; - "test_set_GPU_group_fails_resident_vgpu" >:: test_set_GPU_group_fails_resident_vgpu; +let test_remaining_capacity = + [ "test_remaining_capacity_unsupported_types", `Quick, test_remaining_capacity_unsupported_types + ; "test_remaining_capacity_supported_types", `Quick, test_remaining_capacity_supported_types + ; "test_remaining_capacity_decreases", `Quick, test_remaining_capacity_decreases ] + +let test_set_GPU_group = + [ "test_set_GPU_group_succeeds_empty_pgpu", `Quick, test_set_GPU_group_succeeds_empty_pgpu + ; "test_set_GPU_group_succeeds_orphan_vgpu", `Quick, test_set_GPU_group_succeeds_orphan_vgpu + ; "test_set_GPU_group_fails_resident_vgpu", `Quick, test_set_GPU_group_fails_resident_vgpu + ] + +let test = + ( test_can_run_vgpu + @ test_remaining_capacity + @ test_set_GPU_group + ) diff --git a/ocaml/tests/test_pool_db_backup.ml b/ocaml/tests/test_pool_db_backup.ml index 10516cf5aee..88fdd8081b3 100644 --- a/ocaml/tests/test_pool_db_backup.ml +++ b/ocaml/tests/test_pool_db_backup.ml @@ -12,22 +12,23 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Test_common +module T = Test_common let test_prepare_restore () = + let make_context mac1 mac2 host_uuid dom0_uuid = - let __context = make_test_database () in + let __context = T.make_test_database () in let master = List.hd (Db.Host.get_all ~__context) in Db.Host.set_uuid ~__context ~self:master ~value:host_uuid; List.iter (fun self -> Db.VM.set_uuid ~__context ~self ~value:dom0_uuid) (Db.Host.get_resident_VMs ~__context ~self:master); - let slave = make_host ~__context ~name_label:"slave" () in - let management_net = make_network ~__context ~name_label:"management network" () in - let (_: API.ref_PIF) = make_pif ~__context ~network:management_net ~device:"eth0" ~host:master ~management:true ~mAC:mac1 () in - let (_: API.ref_PIF) = make_pif ~__context ~network:management_net ~device:"eth0" ~host:slave ~management:true ~mAC:mac2 () in + let slave = T.make_host ~__context ~name_label:"slave" () in + let management_net = T.make_network ~__context ~name_label:"management network" () in + let (_: API.ref_PIF) = T.make_pif ~__context ~network:management_net ~device:"eth0" ~host:master ~management:true ~mAC:mac1 () in + let (_: API.ref_PIF) = T.make_pif ~__context ~network:management_net ~device:"eth0" ~host:slave ~management:true ~mAC:mac2 () in __context in + let my_installation_uuid = Xapi_inventory.lookup Xapi_inventory._installation_uuid in let my_control_uuid = Xapi_inventory.lookup Xapi_inventory._control_domain_uuid in let old_context = make_context "1" "2" my_installation_uuid my_control_uuid in @@ -35,22 +36,23 @@ let test_prepare_restore () = Pool_db_backup.prepare_database_for_restore ~old_context ~new_context; let all_hosts = Db.Host.get_all ~__context:new_context in (* new_context should have exactly 1 host: the master *) - assert_equal ~msg:"test_prepare_restore: should only be 1 host" (List.length all_hosts) 1; + Alcotest.(check int)"test_prepare_restore: should only be 1 host" (List.length all_hosts) 1; + let master = List.hd all_hosts in (* new_context master host should have PIF with MAC "a" *) let pif = List.hd (Db.Host.get_PIFs ~__context:new_context ~self:master) in let mac = Db.PIF.get_MAC ~__context:new_context ~self:pif in - assert_equal ~msg:"test_prepare_restore: PIF should have MAC a" mac "a"; + Alcotest.(check string) "test_prepare_restore: PIF should have MAC a" mac "a"; + (* new_context should have correct master host uuid *) let host_uuid = Db.Host.get_uuid ~__context:new_context ~self:master in - assert_equal ~msg:"test_prepare_restore: master uuid wrong" host_uuid my_installation_uuid; + Alcotest.(check string) "test_prepare_restore: master uuid wrong" host_uuid my_installation_uuid; + (* new_context should have correct master dom0 uuid *) let dom0 = List.hd (Db.Host.get_resident_VMs ~__context:new_context ~self:master) in let dom0_uuid = Db.VM.get_uuid ~__context:new_context ~self:dom0 in - assert_equal ~msg:"test_prepare_restore: master dom0 uuid wrong" dom0_uuid my_control_uuid + Alcotest.(check string) "test_prepare_restore: master dom0 uuid wrong" dom0_uuid my_control_uuid let test = - "test_db_backup" >::: - [ - "test_prepare_restore" >:: test_prepare_restore; + [ "test_prepare_restore", `Quick, test_prepare_restore ] diff --git a/ocaml/tests/test_pool_restore_database.ml b/ocaml/tests/test_pool_restore_database.ml index 568f8d9e3e3..2720ba6c7c5 100644 --- a/ocaml/tests/test_pool_restore_database.ml +++ b/ocaml/tests/test_pool_restore_database.ml @@ -12,10 +12,7 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Test_common -open Dbsync_master - +let alco_power_state = Alcotest_comparators.from_rpc_of_t API.rpc_of_vm_power_state let run_test vm = let (nameLabel, isControlDomain, powerState) = vm in let __context = Test_common.make_test_database () in @@ -27,7 +24,8 @@ let run_test vm = Dbsync_master.reset_vms_running_on_missing_hosts ~__context; - assert_equal ~msg:(Printf.sprintf "The VM %s is not halted" nameLabel) + Alcotest.check alco_power_state + (Printf.sprintf "The VM %s is not halted" nameLabel) (Db.VM.get_power_state ~__context ~self:vm) `Halted let test_cases = [ @@ -40,9 +38,6 @@ let test_cases = [ let test_reset_vms_on_missing_host () = List.iter run_test test_cases - let test = - "pool_restore_database" >::: - [ - "test_reset_vms_on_missing_host" >:: test_reset_vms_on_missing_host; + [ "test_reset_vms_on_missing_host", `Quick, test_reset_vms_on_missing_host ] diff --git a/ocaml/tests/test_workload_balancing.ml b/ocaml/tests/test_workload_balancing.ml index 7134ad8b2ed..00814fb4ecb 100644 --- a/ocaml/tests/test_workload_balancing.ml +++ b/ocaml/tests/test_workload_balancing.ml @@ -12,18 +12,20 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Test_common +let split = Workload_balancing.split_host_port -let test_split_host_port () = - let split = Workload_balancing.split_host_port in - let assert_succeed url host port = - assert_equal (split url) (host, port) - in - let assert_raise_url_invalid url = - assert_raises_api_error Api_errors.wlb_url_invalid ~args:[url] (fun () -> split url) - in +let assert_succeed url host port = + Alcotest.(check (pair string int)) + "test_split_host_port" + (host, port) (split url) + +let assert_raise_url_invalid url = + Alcotest.check_raises + "wlb URL should be invalid" + Api_errors.(Server_error (wlb_url_invalid, [url])) + (fun () -> split url |> ignore) +let test_split_host_port () = (* succeed cases *) assert_succeed "192.168.0.1:80" "192.168.0.1" 80; assert_succeed "hostname.com:80" "hostname.com" 80; @@ -47,7 +49,5 @@ let test_split_host_port () = assert_raise_url_invalid "http://example.com:80/" let test = - "test_workload_balancing" >::: - [ - "test_split_host_port" >:: test_split_host_port; + [ "test_split_host_port", `Quick, test_split_host_port ] diff --git a/ocaml/tests/test_xapi_db_upgrade.ml b/ocaml/tests/test_xapi_db_upgrade.ml index 9fcf5c6d882..eadf23eb1f9 100644 --- a/ocaml/tests/test_xapi_db_upgrade.ml +++ b/ocaml/tests/test_xapi_db_upgrade.ml @@ -12,13 +12,11 @@ * GNU Lesser General Public License for more details. *) -open OUnit -open Test_common -open Xapi_db_upgrade -open Stdext +module T = Test_common +module X = Xapi_db_upgrade let upgrade_vm_memory_for_dmc () = - let __context = make_test_database () in + let __context = T.make_test_database () in let self = List.hd (Db.VM.get_all ~__context) in @@ -27,12 +25,16 @@ let upgrade_vm_memory_for_dmc () = Db.VM.set_memory_target ~__context ~self ~value:2L; Db.VM.set_memory_dynamic_max ~__context ~self ~value:3L; (* Apply the upgrade rule *) - upgrade_vm_memory_for_dmc.fn ~__context; + X.upgrade_vm_memory_for_dmc.fn ~__context; let r = Db.VM.get_record ~__context ~self in - assert_equal ~msg:"upgrade_vm_memory_for_dmc: control domain memory_dynamic_min <> memory_target" - r.API.vM_memory_dynamic_min r.API.vM_memory_target; - assert_equal ~msg:"upgrade_vm_memory_for_dmc: control domain memory_dynamic_max <> memory_target" - r.API.vM_memory_dynamic_max r.API.vM_memory_target; + Alcotest.(check int64) + "upgrade_vm_memory_for_dmc: control domain memory_dynamic_min <> memory_target" + r.API.vM_memory_dynamic_min + r.API.vM_memory_target; + Alcotest.(check int64) + "upgrade_vm_memory_for_dmc: control domain memory_dynamic_max <> memory_target" + r.API.vM_memory_dynamic_max + r.API.vM_memory_target; (* Make this a non-control domain and change all memory fields *) Db.VM.set_is_control_domain ~__context ~self ~value:false; @@ -42,88 +44,112 @@ let upgrade_vm_memory_for_dmc () = Db.VM.set_memory_dynamic_max ~__context ~self ~value:3L; Db.VM.set_memory_static_max ~__context ~self ~value:4L; (* Apply the upgrade rule *) - upgrade_vm_memory_for_dmc.fn ~__context; + X.upgrade_vm_memory_for_dmc.fn ~__context; + let r = Db.VM.get_record ~__context ~self in - assert_equal ~msg:"upgrade_vm_memory_for_dmc: memory_dynamic_max <> memory_static_max" - r.API.vM_memory_dynamic_max r.API.vM_memory_static_max; - assert_equal ~msg:"upgrade_vm_memory_for_dmc: memory_target <> memory_static_max" - r.API.vM_memory_target r.API.vM_memory_static_max; - assert_equal ~msg:"upgrade_vm_memory_for_dmc: memory_dynamic_min <> memory_static_max" - r.API.vM_memory_dynamic_min r.API.vM_memory_static_max; - assert_bool "upgrade_vm_memory_for_dmc: memory_static_min > memory_static_max" + Alcotest.(check int64) + "upgrade_vm_memory_for_dmc: memory_dynamic_max <> memory_static_max" + r.API.vM_memory_dynamic_max + r.API.vM_memory_static_max; + + Alcotest.(check int64) + "upgrade_vm_memory_for_dmc: memory_target <> memory_static_max" + r.API.vM_memory_target + r.API.vM_memory_static_max; + + Alcotest.(check int64) + "upgrade_vm_memory_for_dmc: memory_dynamic_min <> memory_static_max" + r.API.vM_memory_dynamic_min + r.API.vM_memory_static_max; + + Alcotest.(check bool) + "upgrade_vm_memory_for_dmc: memory_static_min > memory_static_max" + true (r.API.vM_memory_static_min <= r.API.vM_memory_static_max) let upgrade_bios () = let check inventory bios_strings = - Unixext.mkdir_safe "/var/tmp" 0o755; - Unixext.write_string_to_file "/var/tmp/.previousInventory" inventory; - let __context = make_test_database () in - upgrade_bios_strings.fn ~__context; + Xapi_stdext_unix.Unixext.mkdir_safe "/var/tmp" 0o755; + Xapi_stdext_unix.Unixext.write_string_to_file "/var/tmp/.previousInventory" inventory; + let __context = T.make_test_database () in + X.upgrade_bios_strings.fn ~__context; let _, vm_r = List.hd (Db.VM.get_all_records ~__context) in - assert_equal ~msg:"bios strings upgrade" - vm_r.API.vM_bios_strings bios_strings + Alcotest.(check (list (pair string string))) + "bios strings upgrade" + vm_r.API.vM_bios_strings + bios_strings in check "OEM_MANUFACTURER=Dell" Xapi_globs.old_dell_bios_strings; check "OEM_MANUFACTURER=HP" Xapi_globs.old_hp_bios_strings; check "" Xapi_globs.generic_bios_strings; - Unixext.unlink_safe "/var/tmp/.previousInventory" + Xapi_stdext_unix.Unixext.unlink_safe "/var/tmp/.previousInventory" let update_snapshots () = - let __context = make_test_database () in - let a = make_vm ~__context ~name_label:"a" () in - let a_snap = make_vm ~__context ~name_label:"a snap" () in + let __context = T.make_test_database () in + let a = T.make_vm ~__context ~name_label:"a" () in + let a_snap = T.make_vm ~__context ~name_label:"a snap" () in Db.VM.set_snapshot_of ~__context ~self:a_snap ~value:a; - Db.VM.set_snapshot_time ~__context ~self:a_snap ~value:(Date.of_float 1.); + Db.VM.set_snapshot_time ~__context ~self:a_snap ~value:(Stdext.Date.of_float 1.); - let b = make_vm ~__context ~name_label:"b" () in - let b_snap = make_vm ~__context ~name_label:"b snap" () in + let b = T.make_vm ~__context ~name_label:"b" () in + let b_snap = T.make_vm ~__context ~name_label:"b snap" () in Db.VM.set_snapshot_of ~__context ~self:b_snap ~value:b; - Db.VM.set_snapshot_time ~__context ~self:b_snap ~value:(Date.of_float 1.); - let b_snap2 = make_vm ~__context ~name_label:"b snap2" () in + Db.VM.set_snapshot_time ~__context ~self:b_snap ~value:(Stdext.Date.of_float 1.); + + let b_snap2 = T.make_vm ~__context ~name_label:"b snap2" () in Db.VM.set_snapshot_of ~__context ~self:b_snap2 ~value:b; - Db.VM.set_snapshot_time ~__context ~self:b_snap2 ~value:(Date.of_float 2.); + Db.VM.set_snapshot_time ~__context ~self:b_snap2 ~value:(Stdext.Date.of_float 2.); - update_snapshots.fn ~__context; + X.update_snapshots.fn ~__context; + let check_vm = Alcotest.check Alcotest_comparators.(ref ()) in (* a.parent = a_snap *) - assert_equal ~msg:"a.parent <> a_snap" - (Db.VM.get_parent ~__context ~self:a) a_snap; + check_vm + "a.parent <> a_snap" + a_snap + (Db.VM.get_parent ~__context ~self:a); (* b.parent = b_snap2 *) - assert_equal ~msg:"b.parent <> b_snap2" - (Db.VM.get_parent ~__context ~self:b) b_snap2; + check_vm + "b.parent <> b_snap2" + b_snap2 + (Db.VM.get_parent ~__context ~self:b); (* b_snap2.parent = b_snap *) - assert_equal ~msg:"b_snap2.parent <> b_snap" - (Db.VM.get_parent ~__context ~self:b_snap2)b_snap + check_vm + "b_snap2.parent <> b_snap" + b_snap + (Db.VM.get_parent ~__context ~self:b_snap2) let remove_restricted_pbd_keys () = let restricted_keys = ["SRmaster"] in let other_keys = ["foo"; "bar"] in (* to check we don't remove too much *) let device_config = List.map (fun k -> (k, "some_value")) (restricted_keys @ other_keys) in - let __context = make_test_database () in - let pbd = make_pbd ~__context ~device_config () in + let __context = T.make_test_database () in + let pbd = T.make_pbd ~__context ~device_config () in - remove_restricted_pbd_keys.fn ~__context; + X.remove_restricted_pbd_keys.fn ~__context; let device_config' = Db.PBD.get_device_config ~__context ~self:pbd in List.iter (fun k -> - assert_bool (Printf.sprintf "Restricted key, %s, not removed from PBD.device_config" k) - (not (List.mem_assoc k device_config')) + Alcotest.(check bool) + (Printf.sprintf "Restricted key, %s, not removed from PBD.device_config" k) + false + (List.mem_assoc k device_config') ) restricted_keys; List.iter (fun k -> - assert_bool (Printf.sprintf "Non-restricted key, %s, removed from PBD.device_config" k) + Alcotest.(check bool) + (Printf.sprintf "Non-restricted key, %s, removed from PBD.device_config" k) + true (List.mem_assoc k device_config') ) other_keys let test = - "test_db_upgrade" >::: - [ - "upgrade_vm_memory_for_dmc" >:: upgrade_vm_memory_for_dmc; - "upgrade_bios" >:: upgrade_bios; - "update_snapshots" >:: update_snapshots; - "remove_restricted_pbd_keys" >:: remove_restricted_pbd_keys; + [ "upgrade_vm_memory_for_dmc", `Quick, upgrade_vm_memory_for_dmc + ; "upgrade_bios", `Quick, upgrade_bios + ; "update_snapshots", `Quick, update_snapshots + ; "remove_restricted_pbd_keys", `Quick, remove_restricted_pbd_keys ]