Python kubernetes_e2e.parse_args函数代码示例

    def test_kubeadm_pull(self):
        """Make sure kubeadm pull mode is fine overall."""
        args = kubernetes_e2e.parse_args([
            '--mode=local',
            '--kubeadm=pull',
            '--use-shared-build=bazel'
        ])
        self.assertEqual(args.mode, 'local')
        self.assertEqual(args.kubeadm, 'pull')
        self.assertEqual(args.use_shared_build, 'bazel')

        gcs_bucket = "gs://kubernetes-release-dev/bazel/v1.8.0-beta.1.132+599539dc0b9997"

        def fake_gcs_path(path):
            bazel_default = os.path.join(
                'gs://kubernetes-jenkins/shared-results', 'bazel-build-location.txt')
            self.assertEqual(path, bazel_default)
            return gcs_bucket
        with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
            with Stub(kubernetes_e2e, 'read_gcs_path', fake_gcs_path):
                kubernetes_e2e.main(args)

        self.assertNotIn('E2E_OPT', self.envs)
        version = '%s/bin/linux/amd64/' % gcs_bucket
        self.assertIn('--kubernetes-anywhere-kubeadm-version=%s' % version, self.callstack[-1])

 def test_check_leaks_false_docker(self):
     """Ensure we also set FAIL_ON_GCP_RESOURCE_LEAK when mode=docker."""
     args = kubernetes_e2e.parse_args(['--mode=docker', '--check-leaked-resources=false'])
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
         self.assertIn('--check-leaked-resources=false', self.callstack[-1])
         self.assertIn('-e FAIL_ON_GCP_RESOURCE_LEAK=false', self.callstack[-1])

 def test_check_leaks_unset(self):
     """Ensure --check-leaked-resources=true sends flag to kubetest."""
     args = kubernetes_e2e.parse_args(['--mode=local'])
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
         self.assertNotIn('--check-leaked-resources', self.callstack[-1])
         self.assertEquals('false', self.envs.get('FAIL_ON_GCP_RESOURCE_LEAK'))

    def test_aws(self):
        temp = tempfile.NamedTemporaryFile()
        args = kubernetes_e2e.parse_args([
            '--aws',
            '--cluster=foo',
            '--aws-cluster-domain=test-aws.k8s.io',
            '--aws-ssh=%s' % temp.name,
            '--aws-pub=%s' % temp.name,
            '--aws-cred=%s' % temp.name,
            ])
        with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
            kubernetes_e2e.main(args)

        lastcall = self.callstack[-1]
        self.assertIn('kops-e2e-runner.sh', lastcall)
        self.assertIn('--kops-cluster=foo.test-aws.k8s.io', lastcall)
        self.assertIn('--kops-zones', lastcall)
        self.assertIn('--kops-state=s3://k8s-kops-jenkins/', lastcall)
        self.assertIn('--kops-nodes=4', lastcall)
        self.assertIn('--kops-ssh-key', lastcall)

        self.assertEqual(
            self.envs['JENKINS_AWS_SSH_PRIVATE_KEY_FILE'], temp.name)
        self.assertEqual(
            self.envs['JENKINS_AWS_SSH_PUBLIC_KEY_FILE'], temp.name)
        self.assertEqual(
            self.envs['JENKINS_AWS_CREDENTIALS_FILE'], temp.name)

 def test_migrated_kubetest_args(self):
     migrated = [
         '--stage=a-stage',
         '--stage-suffix=panda',
         '--random-flag', 'random-value',
         '--multiple-federations',
         'arg1', 'arg2',
         '--federation',
         '--kubemark',
         '--extract=this',
         '--extract=that',
         '--perf-tests',
         '--deployment=yay',
         '--save=somewhere',
         '--skew',
         '--publish=location',
         '--timeout=42m',
         '--upgrade_args=ginkgo',
         '--check-leaked-resources=true',
         '--charts',
     ]
     args = kubernetes_e2e.parse_args(['--mode=docker'] + migrated + ['--test=false'])
     self.assertEquals(migrated, args.kubetest_args)
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
     lastcall = self.callstack[-2]
     for arg in migrated:
         self.assertIn(arg, lastcall)

 def test_updown_set(self):
     args = kubernetes_e2e.parse_args(['--mode=local', '--up=false', '--down=true'])
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
     lastcall = self.callstack[-1]
     self.assertNotIn('--up', lastcall)
     self.assertIn('--down', lastcall)

 def test_updown_default(self):
     args = kubernetes_e2e.parse_args([])
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
     lastcall = self.callstack[-1]
     self.assertIn('--up', lastcall)
     self.assertIn('--down', lastcall)

 def test_parse_args_order_agnostic(self):
     args = kubernetes_e2e.parse_args([
         '--mode=local',
         '--some-kubetest-arg=foo',
         '--cluster=test'])
     self.assertEqual(args.kubetest_args, ['--some-kubetest-arg=foo'])
     self.assertEqual(args.mode, 'local')
     self.assertEqual(args.cluster, 'test')

 def test_env_docker(self):
     env = 'FOO=bar blatz'
     args = kubernetes_e2e.parse_args([
         '--mode=docker',
         '--env=' + env,
     ])
     kubernetes_e2e.main(args)
     self.assertIn('-e '+env, self.callstack[-2])

    def test_local(self):
        """Make sure local mode is fine overall."""
        args = kubernetes_e2e.parse_args()
        with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
            kubernetes_e2e.main(args)

        self.assertNotEqual(self.envs, {})
        for call in self.callstack:
            self.assertFalse(call.startswith('docker'))

 def test_default_tag(self):
     """Ensure the default tag exists on gcr.io."""
     args = kubernetes_e2e.parse_args()
     match = re.match('gcr.io/([^:]+):(.+)', kubernetes_e2e.kubekins(args.tag))
     self.assertIsNotNone(match)
     url = 'https://gcr.io/v2/%s/manifests/%s' % (match.group(1),
                                                  match.group(2))
     data = json.loads(urllib.urlopen(url).read())
     self.assertNotIn('errors', data)
     self.assertIn('name', data)

    def test_docker(self):
        """Make sure docker mode is fine overall."""
        args = kubernetes_e2e.parse_args(['--mode=docker'])
        self.assertEqual(args.mode, 'docker')
        with Stub(kubernetes_e2e, 'check_env', fake_bomb):
            kubernetes_e2e.main(args)

        self.assertEqual(self.envs, {})
        call = self.callstack[-2]
        self.assertTrue(call.startswith('docker'), call)

 def test_env_local(self):
     env = 'FOO'
     value = 'BLAT'
     args = kubernetes_e2e.parse_args([
         '--mode=local',
         '--env={env}={value}'.format(env=env, value=value),
     ])
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         kubernetes_e2e.main(args)
     self.assertIn(env, self.envs)
     self.assertEqual(self.envs[env], value)

 def test_use_shared_build(self):
     # normal path
     args = kubernetes_e2e.parse_args([
         '--use-shared-build=bazel'
     ])
     def expect_bazel_gcs(path):
         bazel_default = os.path.join(
             'gs://kubernetes-jenkins/shared-results', 'bazel-build-location.txt')
         self.assertEqual(path, bazel_default)
         return always_kubernetes()
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         with Stub(kubernetes_e2e, 'read_gcs_path', expect_bazel_gcs):
             with Stub(time, 'sleep', fake_pass):
                 kubernetes_e2e.main(args)
     lastcall = self.callstack[-1]
     self.assertIn('--extract=kubernetes', lastcall)
     # normal path, not bazel
     args = kubernetes_e2e.parse_args([
         '--use-shared-build'
     ])
     def expect_normal_gcs(path):
         bazel_default = os.path.join(
             'gs://kubernetes-jenkins/shared-results', 'build-location.txt')
         self.assertEqual(path, bazel_default)
         return always_kubernetes()
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         with Stub(kubernetes_e2e, 'read_gcs_path', expect_normal_gcs):
             kubernetes_e2e.main(args)
     lastcall = self.callstack[-1]
     self.assertIn('--extract=kubernetes', lastcall)
     # test failure to read shared path from GCS
     with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
         with Stub(kubernetes_e2e, 'read_gcs_path', raise_urllib2_error):
             with Stub(os, 'getcwd', always_kubernetes):
                 with Stub(time, 'sleep', fake_pass):
                     try:
                         kubernetes_e2e.main(args)
                     except RuntimeError as err:
                         if not err.message.startswith('Failed to get shared build location'):
                             raise err

    def test_kubeadm_pull(self):
        """Make sure kubeadm pull mode is fine overall."""
        args = kubernetes_e2e.parse_args(['--mode=local', '--kubeadm=pull'])
        self.assertEqual(args.mode, 'local')
        self.assertEqual(args.kubeadm, 'pull')
        fake_env = {'PULL_NUMBER': 1234, 'PULL_REFS': 'master:abcd'}
        with Stub(kubernetes_e2e, 'check_env', self.fake_check_env):
            with Stub(os, 'environ', fake_env):
                kubernetes_e2e.main(args)

        self.assertNotIn('E2E_OPT', self.envs)
        version = 'gs://kubernetes-release-dev/bazel/1234/master:abcd/bin/linux/amd64/'
        self.assertIn('--kubernetes-anywhere-kubeadm-version=%s' % version, self.callstack[-1])