all tests: added meta.maintainers section

nixos/lib/testing.nix

···
             ${lib.optionalString (builtins.length vms == 1) "--set USE_SERIAL 1"}
         ''; # "
 
-      test = runTests driver;
-
-      report = releaseTools.gcovReport { coverageRuns = [ test ]; };
+      passMeta = drv: drv // lib.optionalAttrs (t ? meta) {
+        meta = (drv.meta or {}) // t.meta;
+      };
 
-    in (if makeCoverageReport then report else test) // { inherit nodes driver test; };
+      test = passMeta (runTests driver);
+      report = passMeta (releaseTools.gcovReport { coverageRuns = [ test ]; });
 
+    in (if makeCoverageReport then report else test) // { 
+      inherit nodes driver test; 
+    };
 
   runInMachine =
     { drv

nixos/release.nix

···
         services.postgresql.package = pkgs.postgresql93;
         environment.systemPackages = [ pkgs.php ];
       });
-
   };
-
 }

nixos/tests/avahi.nix

···
 # Test whether `avahi-daemon' and `libnss-mdns' work as expected.
-
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ... } : {
   name = "avahi";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow wizeman ];
+  };
 
   nodes = {
     one =
···
        $two->succeed("getent hosts one.local >&2");
        $two->succeed("getent hosts two.local >&2");
     '';
-}
+})

nixos/tests/bittorrent.nix

···
 
 {
   name = "bittorrent";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow rob wkennington ];
+  };
 
   nodes =
     { tracker =

nixos/tests/blivet.nix

···
 import ./make-test.nix ({ pkgs, ... }: with pkgs.pythonPackages; rec {
   name = "blivet";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig ];
+  };
 
   machine = {
     environment.systemPackages = [ pkgs.python blivet mock ];

nixos/tests/cadvisor.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ... } : {
   name = "cadvisor";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     machine = { config, pkgs, ... }: {
···
       $influxdb->waitForUnit("cadvisor.service");
       $influxdb->succeed("curl http://localhost:8080/containers/");
     '';
-}
+})

nixos/tests/check-filesystems.nix

···
 
 rec {
   name = "check-filesystems";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes = {
     share = {pkgs, config, ...}: {

nixos/tests/chromium.nix

···
 , ...
 }: rec {
   name = "chromium";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig ];
+  };
 
   enableOCR = true;
 

nixos/tests/cjdns.nix

···
 
 in
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "cjdns";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ emery ];
+  };
 
   nodes = rec
     { # Alice finds peers over over ETHInterface.
···
 
       $bob->succeed("curl --fail -g http://[$aliceIp6]");
     '';
-}
+})

nixos/tests/containers.nix

···
 # Test for NixOS' container support.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "containers";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aristid aszlig eelco chaoflow ];
+  };
 
   machine =
     { config, pkgs, ... }:
···
       $machine->fail("nixos-container destroy webserver");
     '';
 
-}
+})

nixos/tests/docker-registry.nix

···
 # This test runs docker-registry and check if it works
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "docker-registry";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     registry = { config, pkgs, ... }: {
···
     $client2->succeed("docker pull registry:8080/scratch");
     $client2->succeed("docker images | grep scratch");
   '';
-}
+})

nixos/tests/docker.nix

···
 # This test runs docker and checks if simple container starts
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "docker";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     docker =
···
     $docker->succeed("docker ps | grep sleeping");
     $docker->succeed("docker stop sleeping");
   '';
-
-}
+})

nixos/tests/etcd.nix

···
 # This test runs etcd as single node, multy node and using discovery
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ... } : {
   name = "etcd";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     simple =
···
       $discovery2->waitUntilSucceeds("etcdctl get /foo/bar | grep 'Hello world'");
     };
   '';
-}
+})

nixos/tests/firefox.nix

···
 import ./make-test.nix ({ pkgs, ... }: {
   name = "firefox";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow shlevy ];
+  };
 
   machine =
     { config, pkgs, ... }:

nixos/tests/firewall.nix

···
 # Test the firewall module.
 
-import ./make-test.nix {
+import ./make-test.nix ( { pkgs, ... } : {
   name = "firewall";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes =
     { walled =
···
       $walled->stopJob("firewall");
       $attacker->succeed("curl -v http://walled/ >&2");
     '';
-
-}
+})

nixos/tests/fleet.nix

···
-import ./make-test.nix rec {
+import ./make-test.nix ({ pkgs, ...} : rec {
   name = "simple";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     node1 =
···
       $node1->succeed("fleetctl stop hello.service");
       $node1->succeed("fleetctl destroy hello.service");
     '';
-}
+})

nixos/tests/gitlab.nix

···
 # This test runs gitlab and checks if it works
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "gitlab";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric offline ];
+  };
 
   nodes = {
     gitlab = { config, pkgs, ... }: {
···
     $gitlab->waitForUnit("gitlab-sidekiq.service");
     $gitlab->waitUntilSucceeds("curl http://localhost:8080/users/sign_in");
   '';
-}
+})

nixos/tests/gnome3.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "gnome3";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow lethalman ];
+  };
 
   machine =
     { config, pkgs, ... }:
···
       $machine->sleep(20);
       $machine->screenshot("screen");
     '';
-
-}
+})

nixos/tests/i3wm.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "i3wm";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig ];
+  };
 
   machine = { lib, pkgs, ... }: {
     imports = [ ./common/x11.nix ./common/user-account.nix ];
···
     $machine->sleep(1);
     $machine->screenshot("terminal");
   '';
-}
+})

nixos/tests/influxdb.nix

···
 # This test runs influxdb and checks if influxdb is up and running
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "influxdb";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ chaoflow offline ];
+  };
 
   nodes = {
     one = { config, pkgs, ... }: {
···
         --data-urlencode 'q=select * from foo limit 1' | grep 6666
     ~);
   '';
-}
+})

nixos/tests/installer.nix

···
   makeInstallerTest = name:
     { createPartitions, preBootCommands ? "", extraConfig ? ""
     , grubVersion ? 2, grubDevice ? "/dev/vda"
-    , grubIdentifier ? "uuid", enableOCR ? false
+    , grubIdentifier ? "uuid", enableOCR ? false, meta ? {}
     }:
     makeTest {
       inherit enableOCR;
       name = "installer-" + name;
-
+      meta = with pkgs.stdenv.lib.maintainers; {
+        # put global maintainers here, individuals go into makeInstallerTest fkt call
+        maintainers = [ wkennington ] ++ (meta.maintainers or []);
+      };
       nodes = {
 
         # The configuration of the machine used to run "nixos-install". It

nixos/tests/ipv6.nix

···
 # Test of IPv6 functionality in NixOS, including whether router
 # solicication/advertisement using radvd works.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "ipv6";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes =
     { client = { config, pkgs, ... }: { };
···
 
       # TODO: test reachability of a machine on another network.
     '';
-
-}
+})

nixos/tests/jenkins.nix

···
 #   2. jenkins user can be extended on both master and slave
 #   3. jenkins service not started on slave node
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "jenkins";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ bjornfor coconnor iElectric eelco chaoflow ];
+  };
 
   nodes = {
 
···
 
     $slave->mustFail("systemctl is-enabled jenkins.service");
   '';
-}
+})

nixos/tests/kde4.nix

···
 import ./make-test.nix ({ pkgs, ... }: {
   name = "kde4";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow ];
+  };
 
   machine =
     { config, pkgs, ... }:

nixos/tests/kexec.nix

···
 # Test whether fast reboots via kexec work.
 
-import ./make-test.nix  {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "kexec";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   machine = { config, pkgs, ... }:
     { virtualisation.vlans = [ ]; };
···
       $machine->{connected} = 0;
       $machine->waitForUnit("multi-user.target");
     '';
-
-}
+})

nixos/tests/kubernetes.nix

···
 # This test runs two node kubernetes cluster and checks if simple redis pod works
 
-import ./make-test.nix rec {
+import ./make-test.nix ({ pkgs, ...} : rec {
   name = "kubernetes";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   redisMaster = builtins.toFile "redis-master-pod.yaml" ''
       id: redis-master-pod
···
     }
 
   '';
-}
+})

nixos/tests/lightdm.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "lightdm";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig ];
+  };
 
   machine = { lib, ... }: {
     imports = [ ./common/user-account.nix ];
···
     $machine->waitForText(qr/^\d{2}(?::\d{2}){2} (?:AM|PM)$/m);
     $machine->screenshot("session");
   '';
-}
+})

nixos/tests/login.nix

···
 
 {
   name = "login";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   machine =
     { config, pkgs, lib, ... }:

nixos/tests/logstash.nix

···
 # This test runs logstash and checks if messages flows and
 # elasticsearch is started.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "logstash";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow offline ];
+  };
 
   nodes = {
     one =
···
     $one->fail("journalctl -n 20 _SYSTEMD_UNIT=logstash.service | grep dragons");
     $one->waitUntilSucceeds("curl -s http://127.0.0.1:9200/_status?pretty=true | grep logstash");
   '';
-}
+})

nixos/tests/mesos.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "simple";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   machine = { config, pkgs, ... }: {
     services.zookeeper.enable = true;
···
       $machine->waitForUnit("mesos-master.service");
       $machine->waitForUnit("mesos-slave.service");
     '';
-}
+})

nixos/tests/misc.nix

···
 # Miscellaneous small tests that don't warrant their own VM run.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "misc";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   machine =
     { config, lib, pkgs, ... }:
···
           $machine->succeed("nix-store -qR /run/current-system | grep nixos-");
       };
     '';
-
-}
+})

nixos/tests/mpich.nix

···
 # Simple example to showcase distributed tests using NixOS VMs.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "mpich";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes = {
     master =
···
 
        $master->succeed("mpiexec -n 2 ./example >&2");
     '';
-}
+})

nixos/tests/mumble.nix

···
-import ./make-test.nix (
+import ./make-test.nix ({ pkgs, ...} : 
 
 let
   client = { config, pkgs, ... }: {
···
 in
 {
   name = "mumble";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ thoughtpolice eelco chaoflow ];
+  };
 
   nodes = {
     server = { config, pkgs, ... }: {

nixos/tests/munin.nix

···
 # This test runs basic munin setup with node and cron job running on the same
 # machine.
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "munin";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow ];
+  };
 
   nodes = {
     one =
···
     $one->waitForFile("/var/lib/munin/one/one-uptime-uptime-g.rrd");
     $one->waitForFile("/var/www/munin/one/index.html");
   '';
-}
+})

nixos/tests/mysql-replication.nix

···
-import ./make-test.nix (
+import ./make-test.nix ({ pkgs, ...} :
 
 let
   replicateUser = "replicate";
···
 
 {
   name = "mysql-replication";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow shlevy ];
+  };
 
   nodes = {
     master =

nixos/tests/mysql.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "mysql";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow shlevy ];
+  };
 
   nodes = {
     master =
···
     $master->sleep(10); # Hopefully this is long enough!!
     $master->succeed("echo 'use testdb; select * from tests' | mysql -u root -N | grep 4");
   '';
-}
+})

nixos/tests/nat.nix

···
 # client on the inside network, a server on the outside network, and a
 # router connected to both that performs Network Address Translation
 # for the client.
-import ./make-test.nix ({ withFirewall, ... }:
+import ./make-test.nix ({ pkgs, withFirewall, ... }:
   let
     unit = if withFirewall then "firewall" else "nat";
   in
   {
     name = "nat${if withFirewall then "WithFirewall" else "Standalone"}";
+  meta = with pkgs.stdenv.lib.maintainers; {
+      maintainers = [ eelco chaoflow rob wkennington ];
+    };
 
     nodes =
       { client =

nixos/tests/networking-proxy.nix

···
 
         virtualisation.memorySize = 128;
       };
-in import ./make-test.nix {
+in import ./make-test.nix ({ pkgs, ...} : {
   name = "networking-proxy";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [  ];
+  };
 
   nodes = {
     # no proxy
···
       $machine4->mustSucceed("su - alice -c 'env | grep -i ftp_proxy | grep 000'");
       $machine4->mustSucceed("su - alice -c 'env | grep -i no_proxy | grep 131415'");
     '';
-
-}
+})

nixos/tests/networking.nix

···
-import ./make-test.nix ({ networkd, test, ... }:
+import ./make-test.nix ({ pkgs, networkd, test, ... }:
   let
     router = { config, pkgs, ... }:
       with pkgs.lib;
···
     case = testCases.${test};
   in case // {
     name = "${case.name}-Networking-${if networkd then "Networkd" else "Scripted"}";
+    meta = with pkgs.stdenv.lib.maintainers; {
+      maintainers = [ wkennington ];
+    };
   })

nixos/tests/nfs.nix

···
-import ./make-test.nix ({ version ? 4, ... }:
+import ./make-test.nix ({ pkgs, version ? 4, ... }:
 
 let
 
···
 
 {
   name = "nfs";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow wkennington ];
+  };
 
   nodes =
     { client1 = client;
···
       my $duration = time - $t1;
       die "shutdown took too long ($duration seconds)" if $duration > 30;
     '';
-
 })

nixos/tests/nsd.nix

···
     # for a host utility with IPv6 support
     environment.systemPackages = [ pkgs.bind ];
   };
-in import ./make-test.nix {
+in import ./make-test.nix ({ pkgs, ...} : {
   name = "nsd";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig ];
+  };
 
   nodes = {
     clientv4 = { lib, nodes, ... }: {
···
       };
     }
   '';
-}
+})

nixos/tests/openssh.nix

···
 
 in {
   name = "openssh";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig eelco chaoflow ];
+  };
 
   nodes = {
 

nixos/tests/panamax.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "panamax";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   machine = { config, pkgs, ... }: {
     services.panamax.enable = true;
···
       $machine->succeed("curl --fail http://localhost:8888/ > /dev/null");
       $machine->shutdown;
     '';
-}
+})

nixos/tests/peerflix.nix

···
 # This test runs peerflix and checks if peerflix starts
 
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "peerflix";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ offline ];
+  };
 
   nodes = {
     peerflix =
···
     $peerflix->waitForUnit("peerflix.service");
     $peerflix->waitUntilSucceeds("curl localhost:9000");
   '';
-
-}
+})

nixos/tests/phabricator.nix

···
 import ./make-test.nix ({ pkgs, ... }: {
   name = "phabricator";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ chaoflow ];
+  };
 
   nodes = {
     storage =

nixos/tests/printing.nix

···
 
 import ./make-test.nix ({pkgs, ... }: {
   name = "printing";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow jgeerds vcunat ];
+  };
 
   nodes = {
 
···
           };
       }
     '';
-
 })

nixos/tests/proxy.nix

···
-import ./make-test.nix (
+import ./make-test.nix ({ pkgs, ...} : 
 
 let
 
···
 
 {
   name = "proxy";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes =
     { proxy =
···
       $backend2->unblock;
       $client->succeed("curl --fail http://proxy/");
     '';
-
 })

nixos/tests/quake3.nix

···
-import ./make-test.nix (
+import ./make-test.nix ({ pkgs, ...} :
 
 let
 
···
 
 rec {
   name = "quake3";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ iElectric eelco chaoflow ];
+  };
 
   # TODO: lcov doesn't work atm
   #makeCoverageReport = true;

nixos/tests/rabbitmq.nix

···
 
 import ./make-test.nix ({ pkgs, ... }: {
   name = "rabbitmq";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow offline ];
+  };
 
   nodes = {
     one = { config, pkgs, ... }: {

nixos/tests/simple.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "simple";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco ];
+  };
 
   machine = { config, pkgs, ... }: { };
 
···
       $machine->waitForUnit("multi-user.target");
       $machine->shutdown;
     '';
-}
+})

nixos/tests/subversion.nix

···
-import ./make-test.nix (
+import ./make-test.nix ({ pkgs, ...} : 
 
 let
 
···
 
 {
   name = "subversion";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes =
     { webserver =

nixos/tests/tomcat.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "tomcat";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes = {
     server =
···
     $client->succeed("curl --fail http://server/examples/servlets/servlet/HelloWorldExample");
     $client->succeed("curl --fail http://server/examples/jsp/jsp2/simpletag/hello.jsp");
   '';
-
-}
+})

nixos/tests/trac.nix

···
 import ./make-test.nix ({ pkgs, ... }: {
   name = "trac";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   nodes = {
     storage =

nixos/tests/udisks2.nix

···
 
 {
   name = "udisks2";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow ];
+  };
 
   machine =
     { config, pkgs, ... }:

nixos/tests/virtualbox.nix

···
 
 in {
   name = "virtualbox";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ aszlig wkennington ];
+  };
 
   machine = { pkgs, lib, config, ... }: {
     imports = let

nixos/tests/xfce.nix

···
-import ./make-test.nix {
+import ./make-test.nix ({ pkgs, ...} : {
   name = "xfce";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ eelco chaoflow shlevy ];
+  };
 
   machine =
     { config, pkgs, ... }:
···
       $machine->sleep(10);
       $machine->screenshot("screen");
     '';
-
-}
+})