| 
									
										
										
										
											2015-07-12 12:09:40 +02:00
										 |  |  | import ./make-test.nix ({ pkgs, ...} :  | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | let | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |   # Build some packages with coverage instrumentation. | 
					
						
							| 
									
										
										
										
											2010-01-03 17:57:38 +00:00
										 |  |  |   overrides = pkgs: | 
					
						
							|  |  |  |     with pkgs.stdenvAdapters; | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |     let | 
					
						
							|  |  |  |       do = pkg: pkg.override (args: { | 
					
						
							| 
									
										
										
										
											2010-01-03 17:57:38 +00:00
										 |  |  |         stdenv = addCoverageInstrumentation args.stdenv; | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |       }); | 
					
						
							|  |  |  |     in | 
					
						
							|  |  |  |       rec { | 
					
						
							|  |  |  |         apr = do pkgs.apr; | 
					
						
							|  |  |  |         aprutil = do pkgs.aprutil; | 
					
						
							|  |  |  |         apacheHttpd = do pkgs.apacheHttpd; | 
					
						
							|  |  |  |         mod_python = do pkgs.mod_python; | 
					
						
							|  |  |  |         subversion = do pkgs.subversion; | 
					
						
							| 
									
										
										
										
											2009-09-01 22:22:45 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |         # To build the kernel with coverage instrumentation, we need a | 
					
						
							|  |  |  |         # special patch to make coverage data available under /proc. | 
					
						
							| 
									
										
										
										
											2010-06-07 13:54:15 +00:00
										 |  |  |         linux = pkgs.linux.override (orig: { | 
					
						
							| 
									
										
										
										
											2014-03-03 13:39:30 +01:00
										 |  |  |           stdenv = overrideInStdenv pkgs.stdenv [ pkgs.keepBuildTree ]; | 
					
						
							| 
									
										
										
										
											2010-01-04 13:22:43 +00:00
										 |  |  |           extraConfig = | 
					
						
							|  |  |  |             ''
 | 
					
						
							|  |  |  |               GCOV_KERNEL y | 
					
						
							|  |  |  |               GCOV_PROFILE_ALL y | 
					
						
							|  |  |  |             '';
 | 
					
						
							| 
									
										
										
										
											2009-09-01 22:22:45 +00:00
										 |  |  |         }); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |       }; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | in | 
					
						
							| 
									
										
										
										
											2011-09-14 18:20:50 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2010-01-05 11:18:43 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2014-06-28 16:04:49 +02:00
										 |  |  |   name = "subversion"; | 
					
						
							| 
									
										
										
										
											2015-07-12 12:09:40 +02:00
										 |  |  |   meta = with pkgs.stdenv.lib.maintainers; { | 
					
						
							|  |  |  |     maintainers = [ eelco chaoflow ]; | 
					
						
							|  |  |  |   }; | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |   nodes = | 
					
						
							|  |  |  |     { webserver = | 
					
						
							| 
									
										
										
										
											2018-07-20 20:56:59 +00:00
										 |  |  |         { ... }: | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |         { | 
					
						
							|  |  |  |           services.httpd.enable = true; | 
					
						
							|  |  |  |           services.httpd.adminAddr = "e.dolstra@tudelft.nl"; | 
					
						
							|  |  |  |           services.httpd.extraSubservices = | 
					
						
							| 
									
										
										
										
											2012-10-04 12:34:44 -04:00
										 |  |  |             [ { function = import <services/subversion>; | 
					
						
							| 
									
										
										
										
											2009-11-06 16:23:25 +00:00
										 |  |  |                 urlPrefix = ""; | 
					
						
							|  |  |  |                 dataDir = "/data/subversion"; | 
					
						
							|  |  |  |                 userCreationDomain = "192.168.0.0/16"; | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |               } | 
					
						
							|  |  |  |             ]; | 
					
						
							|  |  |  |           nixpkgs.config.packageOverrides = overrides; | 
					
						
							|  |  |  |         }; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |       client = | 
					
						
							| 
									
										
										
										
											2018-07-20 20:56:59 +00:00
										 |  |  |         { pkgs, ... }: | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |         { | 
					
						
							|  |  |  |           environment.systemPackages = [ pkgs.subversion ]; | 
					
						
							|  |  |  |           nixpkgs.config.packageOverrides = overrides; | 
					
						
							|  |  |  |         }; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     }; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2010-01-05 11:18:43 +00:00
										 |  |  |   testScript = | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |     ''
 | 
					
						
							|  |  |  |       startAll; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |       $webserver->waitForOpenPort(80); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       print STDERR $client->succeed("svn --version"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       print STDERR $client->succeed("curl --fail http://webserver/"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Create a new user through the web interface. | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("curl --fail -F username=alice -F fullname='Alice Lastname' -F address=alice\@example.org -F password=foobar -F password_again=foobar http://webserver/repoman/adduser"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2011-09-14 18:20:50 +00:00
										 |  |  |       # Let Alice create a new repository. | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("curl --fail -u alice:foobar --form repo=xyzzy --form description=Xyzzy http://webserver/repoman/create"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("curl --fail http://webserver/") =~ /alice/ or die; | 
					
						
							| 
									
										
										
										
											2011-09-14 18:20:50 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |       # Let Alice do a checkout. | 
					
						
							|  |  |  |       my $svnFlags = "--non-interactive --username alice --password foobar"; | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("svn co $svnFlags http://webserver/repos/xyzzy wc"); | 
					
						
							|  |  |  |       $client->succeed("echo hello > wc/world"); | 
					
						
							|  |  |  |       $client->succeed("svn add wc/world"); | 
					
						
							|  |  |  |       $client->succeed("svn ci $svnFlags -m 'Added world.' wc/world"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Create a new user on the server through the create-user.pl script. | 
					
						
							|  |  |  |       $webserver->execute("svn-server-create-user.pl bob bob\@example.org Bob"); | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $webserver->succeed("svn-server-resetpw.pl bob fnord"); | 
					
						
							|  |  |  |       $client->succeed("curl --fail http://webserver/") =~ /bob/ or die; | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Bob should not have access to the repo. | 
					
						
							|  |  |  |       my $svnFlagsBob = "--non-interactive --username bob --password fnord"; | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->fail("svn co $svnFlagsBob http://webserver/repos/xyzzy wc2"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Bob should not be able change the ACLs of the repo. | 
					
						
							|  |  |  |       # !!! Repoman should really return a 403 here. | 
					
						
							| 
									
										
										
										
											2011-02-17 15:41:28 +00:00
										 |  |  |       $client->succeed("curl --fail -u bob:fnord -F description=Xyzzy -F readers=alice,bob -F writers=alice -F watchers= -F tardirs= http://webserver/repoman/update/xyzzy") | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |           =~ /not authorised/ or die; | 
					
						
							| 
									
										
										
										
											2011-09-14 18:20:50 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |       # Give Bob access. | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("curl --fail -u alice:foobar -F description=Xyzzy -F readers=alice,bob -F writers=alice -F watchers= -F tardirs= http://webserver/repoman/update/xyzzy"); | 
					
						
							| 
									
										
										
										
											2011-09-14 18:20:50 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  |       # So now his checkout should succeed. | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("svn co $svnFlagsBob http://webserver/repos/xyzzy wc2"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Test ViewVC and WebSVN | 
					
						
							| 
									
										
										
										
											2012-10-24 18:22:53 +02:00
										 |  |  |       $client->succeed("curl --fail -u alice:foobar http://webserver/viewvc/xyzzy"); | 
					
						
							|  |  |  |       $client->succeed("curl --fail -u alice:foobar http://webserver/websvn/xyzzy"); | 
					
						
							|  |  |  |       $client->succeed("curl --fail -u alice:foobar http://webserver/repos-xml/xyzzy"); | 
					
						
							| 
									
										
											  
											
												* Stuff for automatic and manual testing of NixOS VMs.
  lib/build-vms.nix contains a function `buildVirtualNetwork' that
  takes a specification of a network of machines (as an attribute set
  of NixOS machine configurations) and builds a script that starts
  each configuration in a separate QEMU/KVM VM and connects them
  together in a virtual network.  This script can be run manually to
  test the VMs interactively.  There is also a function `runTests'
  that starts and runs the virtual network in a derivation, and
  then executes a test specification that tells the VMs to do certain
  things (i.e., letting one VM send an HTTP request to a webserver on
  another VM).  The tests are written in Perl (for now).
  tests/subversion.nix shows a simple example, namely a network of two
  machines: a webserver that runs the Subversion subservice, and a
  client.  Apache, Subversion and a few other packages are built with
  coverage analysis instrumentation.  For instance,
    $ nix-build tests/subversion.nix -A vms
    $ ./result/bin/run-vms
  starts two QEMU/KVM instances.  When they have finished booting, the
  webserver can be accessed from the host through
  http://localhost:8081/.
  It also has a small test suite:
    $ nix-build tests/subversion.nix -A report
  This runs the VMs in a derivation, runs the tests, and then produces
  a distributed code coverage analysis report (i.e. it shows the
  combined coverage on both machines).
  The Perl test driver program is in lib/test-driver.  It executes
  commands on the guest machines by connecting to a root shell running
  on port 514 (provided by modules/testing/test-instrumentation.nix).
  The VMs are connected together in a virtual network using QEMU's
  multicast feature.  This isn't very secure.  At the very least,
  other processes on the same machine can listen to or send packets on
  the virtual network.  On the plus side, we don't need to be root to
  set up a multicast virtual network, so we can do it from a
  derivation.  Maybe we can use VDE instead.
  (Moved from the vario repository.)
svn path=/nixos/trunk/; revision=16899
											
										 
											2009-08-31 14:25:12 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  |       # Stop Apache to gather all the coverage data. | 
					
						
							|  |  |  |       $webserver->stopJob("httpd"); | 
					
						
							|  |  |  |     '';
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2014-04-14 14:02:44 +02:00
										 |  |  | }) |