Merge lp:~deeptik/linaro-license-protection/publish-to-snapshot into lp:~linaro-automation/linaro-license-protection/trunk

[Deepti B. Kalakeri]

Script to move the artifacts from tmp location to permanent location on s.l.o.
I have retained the example uploads and target dir in the script so that it would be easy for you to test the code.
Here is the ex: inputs you can use to verify the script

 1) For Android
 $mkdir -p /tmp/uploads/android/android_user/android_job/1 && cd /tmp/uploads/android/android_user/android_job/1 && touch one two three && cd -
 $scripts/publish_to_snapshots.py -j "android" -u "android_user" -i 1 -n "android_job"
 Moved the files from /tmp/uploads/android/android_user/android_job/1 to /tmp/www/android/android_user/android_job/1
 Move succeeded

 2) For kernel-hwpack
 $ mkdir -p /tmp/uploads/kernel-hwpack/kernel_tree/kernel_tree_job && cd /tmp/uploads/kernel-hwpack/kernel_tree/kernel_tree_job && touch one two three && cd -
 $ scripts/publish_to_snapshots.py -j "kernel-hwpack" -u "android" -i 1 -n "kernel_tree_job" -t "kernel_tree"
 Moved the files from /tmp/uploads/kernel-hwpack/kernel_tree/kernel_tree_job to /tmp/www/kernel-hwpack/kernel_tree/kernel_tree_job
 Move succeeded

[Paul Sokolovsky (pfalcon)]

One immediate comment is inconsistent format of the long options, like "--job_type". It's GNU (originators of long options) convention that long options use dashes as separators. It's of course also looks better and easier to remember. We had/have the same issue with l-m-c: there was non-compliant options, then there was a patch to fix it, then it turned out it breaks existing scripts which pass those options, then the fix had to be reverted or something, etc. So, we should do it rightly from the start.

review: Needs Fixing

[Paul Sokolovsky (pfalcon)]

" help="Specifiy the job type (Ex: android/kernel-hwpack)"

Typo in "specify". Also, would suggest to rewrite to avoid possible confusion, e.g.:
"Specify the job type (Values: android, kernel-hwpack)"

review: Needs Fixing

[Paul Sokolovsky (pfalcon)]

9
parser.add_argument("-a", "--archive_info", dest="archive_info",
10
                    help="Specify the job which resulted the archive to be stored.\
11
                         Ex: ${JOB_NAME}/${BUILD_NUMBER} should be specified for \
12
                             andriod and for \
13
                             kernel-hwpack ${KERNEL_NAME}/${KERNEL_JOB_NAME}")

This seems like confusing option. Reading the help, I don't have an idea why it is called "archive_info". Nor reading help I have clear picture what and how it should be used/works - that's too much specifics, out of context. This script is supposed to be called from Jenkins, and Jenkins cab basically pass to it it job name (in its native format) and build number. That's what script should accept, and help for options should describe just that, any specifics like the fact that job name have internal structure based on --job-type should be left to manual IMHO.

review: Needs Fixing

[lp:~deeptik/linaro-license-protection/publish-to-snapshot]

46. By Georgy Redkozubov on 2012-03-09

[merge] New STE license text

[Paul Sokolovsky (pfalcon)]

Also, short option assignment is not ideal IMHO. For "job type", main word is (t)ype. For "kernel tree" it's (k)ernel (or (r)epository if should be generalized), "build number" is apparently (n)umber, which leaves "job name" to (j)ob.

[Paul Sokolovsky (pfalcon)]

60 + if args.job_type == "android":
61 + build_path = '/'.join([args.job_type, args.user_name, args.job_name])

Well, nope, that's not correct. There's no "user name" on Jenkins level, only job name. That's what this script accepts. It then can reformat native Jenkins name into "external" name which we want to see.

review: Needs Fixing

[Paul Sokolovsky (pfalcon)]

71 + if not (os.path.isdir(uploads_path) or os.path.isdir(build_dir_path)):
72 + print "Missing build path", build_dir_path
73 + return FAIL

The error message is incorrect - it checks 2 dirs, but reports problem as if applies to only one. Such cases are always great source of confusion and suffering (the latest one, (c) by Google: https://bugs.launchpad.net/bugs/949100)

review: Needs Fixing

[Paul Sokolovsky (pfalcon)]

79 + try:
80 + # Make a note of the contents of src dir so that
81 + # it can be used to validate the move to destination
82 + uploads_dirList = os.listdir(build_dir_path)

That sounds complicated and overinsuring. Can't we make requirement that upload dir and destination dir were on the same FS, so we can just use mv? Even if we can't, why wouldn't we trust shutil.copy2()? It either does the copy, or throws an exception, so we can't miss failed move.

Minor note - would be nice to use consistent var naming convention, like uploads_dir_list.

[Paul Sokolovsky (pfalcon)]

111 +def main():
112 + uploads_path = '/srv3/snapshots.linaro.org/uploads/'
113 + target_path = '/srv3/snapshots.linaro.org/www/'
114 + uploads_path = '/tmp/uploads/'
115 + target_path = '/tmp/www/'

IMHO, it would be better to treat these as the constants, not as the variables, to be defined in the beginning of the script (like they were before r50).

[Deepti B. Kalakeri (deeptik)]

Thanks paul for comments. I will reply back on tuesday when am back to office.

Thanks!!!
Deepti

On 3/9/12, Paul Sokolovsky <email address hidden> wrote:
> 111 +def main():
> 112 + uploads_path = '/srv3/snapshots.linaro.org/uploads/'
> 113 + target_path = '/srv3/snapshots.linaro.org/www/'
> 114 + uploads_path = '/tmp/uploads/'
> 115 + target_path = '/tmp/www/'
>
> IMHO, it would be better to treat these as the constants, not as the
> variables, to be defined in the beginning of the script (like they were
> before r50).
>
> --
> https://code.launchpad.net/~deeptik/linaro-license-protection/publish-to-snapshot/+merge/96735
> You are the owner of
> lp:~deeptik/linaro-license-protection/publish-to-snapshot.
>

--
Sent from my mobile device

Thanks and Regards,
Deepti
Infrastructure Team Member, Linaro Platform Teams
Linaro.org | Open source software for ARM SoCs
Follow Linaro: http://www.facebook.com/pages/Linaro
http://twitter.com/#!/linaroorg - http://www.linaro.org/linaro-blog

[Deepti B. Kalakeri (deeptik)]

> " help="Specifiy the job type (Ex: android/kernel-hwpack)"
>
> Typo in "specify". Also, would suggest to rewrite to avoid possible confusion,
> e.g.:
> "Specify the job type (Values: android, kernel-hwpack)"

oops! copy paste effect.. done.

Thanks!!!
Deepti.

[Deepti B. Kalakeri (deeptik)]

>
> 9
> parser.add_argument("-a", "--archive_info", dest="archive_info",
> 10
> help="Specify the job which resulted the archive to be
> stored.\
> 11
> Ex: ${JOB_NAME}/${BUILD_NUMBER} should be specified
> for \
> 12
> andriod and for \
> 13
> kernel-hwpack ${KERNEL_NAME}/${KERNEL_JOB_NAME}")
>
> This seems like confusing option. Reading the help, I don't have an idea why
> it is called "archive_info". Nor reading help I have clear picture what and
> how it should be used/works - that's too much specifics, out of context. This
> script is supposed to be called from Jenkins, and Jenkins cab basically pass
> to it it job name (in its native format) and build number. That's what script
> should accept, and help for options should describe just that, any specifics
> like the fact that job name have internal structure based on --job-type should
> be left to manual IMHO.

There is not archive_info anymore. This was an old change.

> Also, short option assignment is not ideal IMHO. For "job type", main word is
> (t)ype. For "kernel tree" it's (k)ernel (or (r)epository if should be
> generalized), "build number" is apparently (n)umber, which leaves "job name"
> to (j)ob.

Good suggestions. done.

> 60 + if args.job_type == "android":
> 61 + build_path = '/'.join([args.job_type, args.user_name,
> args.job_name])
>
> Well, nope, that's not correct. There's no "user name" on Jenkins level, only
> job name. That's what this script accepts. It then can reformat native Jenkins
> name into "external" name which we want to see.

Yes I agree that there is no username at jenkins level. But for android, I believe the jenkins-post-www.sh script line 38 refer to $TARGET_PATH/~$username/$jobname.
So I just tried to retain the extra work of separating the jobname into username + jobname.
Let me know if this is not required and what exactly did the username in the script meant to be.
I will make the changes accordingly.

> 71 + if not (os.path.isdir(uploads_path) or
> os.path.isdir(build_dir_path)):
> 72 + print "Missing build path", build_dir_path
> 73 + return FAIL
>
> The error message is incorrect - it checks 2 dirs, but reports problem as if
> applies to only one. Such cases are always great source of confusion and
> suffering (the latest one, (c) by Google:
> https://bugs.launchpad.net/bugs/949100)

I agree. Modified this to correct the error message.

> 79 + try:
> 80 + # Make a note of the contents of src dir so that
> 81 + # it can be used to validate the move to destination
> 82 + uploads_dirList = os.listdir(build_dir_path)
>
> That sounds complicated and overinsuring. Can't we make requirement that
> upload dir and destination dir were on the same FS, so we can just use mv?
> Even if we can't, why wouldn't we trust shutil.copy2()? It either does the
> copy, or throws an exception, so we can't miss failed move.
>

I did consider using the mv action for this. shutil.move has the following issue:
1) The destination dir should be non-existent. so in case of kernel hwpacks we intend to store all the hwpack...

[Paul Sokolovsky (pfalcon)]

On Tue, 13 Mar 2012 09:55:27 -0000
"Deepti B. Kalakeri" <email address hidden> wrote:

> >
> > 9
> > parser.add_argument("-a", "--archive_info", dest="archive_info",
> > 10
> > help="Specify the job which resulted the
> > archive to be stored.\
> > 11
> > Ex: ${JOB_NAME}/${BUILD_NUMBER} should be
> > specified for \
> > 12
> > andriod and for \
> > 13
> > kernel-hwpack
> > ${KERNEL_NAME}/${KERNEL_JOB_NAME}")
> >
> > This seems like confusing option. Reading the help, I don't have an
> > idea why it is called "archive_info". Nor reading help I have clear
> > picture what and how it should be used/works - that's too much
> > specifics, out of context. This script is supposed to be called
> > from Jenkins, and Jenkins cab basically pass to it it job name (in
> > its native format) and build number. That's what script should
> > accept, and help for options should describe just that, any
> > specifics like the fact that job name have internal structure based
> > on --job-type should be left to manual IMHO.
>
> There is not archive_info anymore. This was an old change.
>
> > Also, short option assignment is not ideal IMHO. For "job type",
> > main word is (t)ype. For "kernel tree" it's (k)ernel (or
> > (r)epository if should be generalized), "build number" is
> > apparently (n)umber, which leaves "job name" to (j)ob.
>
> Good suggestions. done.
>
> > 60 + if args.job_type == "android":
> > 61 + build_path = '/'.join([args.job_type, args.user_name,
> > args.job_name])
> >
> > Well, nope, that's not correct. There's no "user name" on Jenkins
> > level, only job name. That's what this script accepts. It then can
> > reformat native Jenkins name into "external" name which we want to
> > see.
>
> Yes I agree that there is no username at jenkins level. But for
> android, I believe the jenkins-post-www.sh script line 38 refer to
> $TARGET_PATH/~$username/$jobname.

Yes, and those are parsed from Jenkin job name in line 32 and on:
http://bazaar.launchpad.net/~linaro-infrastructure/linaro-license-protection/trunk/view/head:/scripts/jenkins-post-www.sh#L32

> So I just tried to retain the extra
> work of separating the jobname into username + jobname. Let me know
> if this is not required and what exactly did the username in the
> script meant to be. I will make the changes accordingly.

So, the script should accept ${JOB_NAME} from Jenkins (we simply
don't have anything more specific on its level), but then it should be
ready to parse/convert that into job-type-specific target path (i.e.
this conversion will be different for different job-type). So, I would
suggest to add job_to_target_subdir(job_name, build_no) method to
encapsulate this conversion. For android case, it will be equivalent of
lines 32-38 in jenkins-post-www.sh .

>
> > 71 + if not (os.path.isdir(uploads_path) or
> > os.path.isdir(build_dir_path)):
> > 72 + print "Missing build path", build_dir_path
> > 73 + return FAIL
> >
> > The error message is incorrect - it checks 2 dirs, but reports
> > problem as if applies to only one. Such cases are alway...

[Paul Sokolovsky (pfalcon)]

Ok, based on the further discussion on IRC, this should be good enough to proceed, further elaboration can be done separately.

review: Approve

[lp:~deeptik/linaro-license-protection/publish-to-snapshot]

47. By Deepti B. Kalakeri on 2012-03-14

Script to move the artifacts from tmp location to permanent location on s.l.o.

=== added file 'scripts/__init__.py'
=== added file 'scripts/publish_to_snapshots.py'
--- scripts/publish_to_snapshots.py	1970-01-01 00:00:00 +0000
+++ scripts/publish_to_snapshots.py	2012-03-14 08:03:18 +0000
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# This script moves the artifacts from tmp location to a
+# to a permanent location on s.l.o
+
+import os
+import sys
+import shutil
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-t", "--job-type", dest="job_type",
+                    help="Specify the job type (Ex: android/kernel-hwpack)")
+parser.add_argument("-r", "--ktree", dest="kernel_tree",
+                    help="Specify the kernel tree built by the job")
+parser.add_argument("-j", "--job-name", dest="job_name",
+                    help="Specify the job name which resulted the archive to be stored.\
+                    Ex: ${JOB_NAME} should be specified for andriod and for \
+                    kernel-hwpack ${KERNEL_JOB_NAME}")
+parser.add_argument("-n", "--build-num", dest="build_num", type=int,
+                    help="Specify the job build number for android builds only")
+
+uploads_path = '/srv3/snapshots.linaro.org/uploads/'
+target_path = '/srv3/snapshots.linaro.org/www/'
+PASS = 0 
+FAIL = 1
+acceptable_job_types = [
+    'android',
+    'kernel-hwpack',
+    ]
+
+class SnapshotsPublisher(object):
+ 
+    def validate_args(self, args):
+        # Validate that all the required information 
+        # is passed on the command line
+        if (args.job_type == None or  args.job_name == None): 
+            parser.error("\nYou must specify job-type and job-name")
+            return FAIL
+
+        if (args.job_type == "android" and args.build_num == None):
+            parser.error("You must specify build number")
+            return FAIL
+
+        if (args.job_type == "kernel-hwpack" and args.kernel_tree == None):
+            parser.error("You must specify kernel tree name built by the job")
+            return FAIL
+
+        if (args.job_type not in acceptable_job_types):
+            parser.error("Invalid job type")
+            return FAIL
+
+    def jobname_to_target_subdir(self, args, jobname):
+        ret_val = None
+        if args.job_type == "android":
+            ret_val = jobname.split("_")    
+        return ret_val 
+
+    def validate_paths(self, args, uploads_path, target_path):
+        build_dir_path = target_dir_path = None
+        if args.job_type == "android":
+           build_path = '/'.join([args.job_type, args.job_name,
+                                  str(args.build_num)])
+           build_dir_path = os.path.join(uploads_path, build_path) 
+           ret_val = self.jobname_to_target_subdir(args, args.job_name)
+           if ret_val != None:
+               user_name = ret_val[0]
+               job_name = '_'.join(ret_val[1:])
+               target_dir = '/'.join([args.job_type, user_name, job_name,
+                                      str(args.build_num)])
+               target_dir_path = os.path.join(target_path, target_dir)
+           else:
+               return None, None
+        else:
+           build_path = '/'.join([args.job_type, args.kernel_tree, args.job_name])
+           build_dir_path = os.path.join(uploads_path, build_path)
+           target_dir_path = os.path.join(target_path, build_path)
+
+        if not (os.path.isdir(uploads_path) or os.path.isdir(build_dir_path)):
+            build_paths = "'%s' or '%s'" % (uploads_path, build_dir_path)
+            print "Missing build paths: ", build_paths
+            return None, None
+       
+        if not os.path.isdir(target_path):
+            print "Missing target path", target_path
+            return None, None
+
+        return build_dir_path, target_dir_path
+
+
+    def move_artifacts(self, args, build_dir_path, target_dir_path):
+        try:
+            # Make a note of the contents of src dir so that 
+            # it can be used to validate the move to destination
+            uploads_dir_list = os.listdir(build_dir_path)
+
+            if not os.path.isdir(target_dir_path):
+                os.makedirs(target_dir_path)
+                if not os.path.isdir(target_dir_path):
+                    raise OSError
+
+            for fname in uploads_dir_list:
+                fname = os.path.join(build_dir_path, fname)
+                shutil.copy2(fname, target_dir_path)
+
+            target_dir_list = os.listdir(target_dir_path)
+            for fname in uploads_dir_list:
+                if not fname in target_dir_list:
+                    print "Destination missing file", fname
+                    return FAIL
+
+            shutil.rmtree(build_dir_path)
+            print "Moved the files from '",build_dir_path, "' to '",\
+                  target_dir_path, "'"
+            return PASS
+
+        except OSError, details:
+            print "Failed to create the target path", target_dir_path, ":" , details 
+            return FAIL
+        except shutil.Error:
+            print "Failed to move files destination path", target_dir_path
+            print "Target already exists, move failed"
+            return FAIL
+
+def main():
+    publisher = SnapshotsPublisher()
+    args = parser.parse_args()
+    publisher.validate_args(args)
+    build_dir_path, target_dir_path = publisher.validate_paths(args, uploads_path, 
+                                                               target_path)
+    if build_dir_path == None or target_dir_path == None:
+        print "Problem with build/target path, move failed"
+        return FAIL
+
+    ret  = publisher.move_artifacts(args, build_dir_path, target_dir_path)
+    if ret != PASS:
+        print "Move Failed"
+        return FAIL
+    else:
+        print "Move succeeded"
+        return PASS
+if __name__ == '__main__':
+    sys.exit(main())

=== modified file 'testing/__init__.py'
--- testing/__init__.py	2012-01-12 14:07:05 +0000
+++ testing/__init__.py	2012-03-14 08:03:18 +0000
@@ -1,9 +1,13 @@
 import os
 import unittest
 
+from testing.test_click_through_license import *
+from testing.test_publish_to_snapshots import *
+
 def test_suite():
     module_names = [
-        'testing.test_click_through_license',
+        'testing.test_click_through_license.TestLicense',
+        'testing.test_publish_to_snapshots.TestSnapshotsPublisher',
         ]
     loader = unittest.TestLoader()
     suite = loader.loadTestsFromNames(module_names)

=== added file 'testing/test_publish_to_snapshots.py'
--- testing/test_publish_to_snapshots.py	1970-01-01 00:00:00 +0000
+++ testing/test_publish_to_snapshots.py	2012-03-14 08:03:18 +0000
@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import shutil
+import tempfile
+import argparse
+from StringIO import StringIO
+from testtools import TestCase
+from scripts.publish_to_snapshots import SnapshotsPublisher
+
+class TestSnapshotsPublisher(TestCase):
+    '''Tests for publishing files to the snapshots.l.o www are.'''
+
+    uploads_path = "./uploads/"
+    target_path = "./www/"
+
+    def setUp(self):
+        self.parser =  argparse.ArgumentParser()
+        self.parser.add_argument("-t", "--job-type", dest="job_type")
+        self.parser.add_argument("-r", "--ktree", dest="kernel_tree")
+        self.parser.add_argument("-j", "--job-name", dest="job_name")
+        self.parser.add_argument("-n", "--build-num", dest="build_num", type=int)
+        if not os.path.isdir(self.uploads_path):
+            os.mkdir(self.uploads_path)
+        
+        if not os.path.isdir(self.target_path):
+            os.mkdir(self.target_path)
+        super(TestSnapshotsPublisher, self).setUp()
+
+    def tearDown(self):
+        if os.path.isdir(self.uploads_path):
+            shutil.rmtree(self.uploads_path)
+
+        if os.path.isdir(self.target_path):
+            shutil.rmtree(self.target_path)
+        super(TestSnapshotsPublisher, self).tearDown()
+
+    def test_validate_args_valid_job_values(self):
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', '-n', '1'])
+        self.publisher.validate_args(param)
+        param = self.parser.parse_args(['-t', 'kernel-hwpack', '-r', 'dummy_tree', 
+                                        '-j', 'dummy_job_name'])
+        self.publisher.validate_args(param)
+
+    def test_validate_args_invalid_job_type(self):
+        orig_stderr = sys.stderr
+        stderr = sys.stderr = StringIO()
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'invalid_job_type',  '-j', 'dummy_job_name', 
+                                        '-n', '1'])
+        try:
+            self.publisher.validate_args(param)
+        except SystemExit, err:
+            self.assertEqual(err.code, 2, "Expected result")
+        finally:
+            sys.stderr = orig_stderr
+        stderr.seek(0)
+        self.assertIn("Invalid job type", stderr.read())
+
+
+    def test_validate_args_run_invalid_argument(self):
+        orig_stderr = sys.stderr
+        stderr = sys.stderr = StringIO()
+        self.publisher = SnapshotsPublisher()
+        try:
+            param = self.parser.parse_args(['-a'])
+            self.publisher.validate_args(param)
+        except SystemExit, err:
+            self.assertEqual(err.code, 2, "Invalid argument passed")
+        finally:
+            sys.stderr = orig_stderr
+        stderr.seek(0)
+        self.assertIn("unrecognized arguments: -a\n", stderr.read())
+
+    def test_validate_args_run_invalid_value(self):
+        orig_stderr = sys.stderr
+        stderr = sys.stderr = StringIO()
+        self.publisher = SnapshotsPublisher()
+        try:
+            param = self.parser.parse_args(['-n', "N"])
+            self.publisher.validate_args(param)
+        except SystemExit, err:
+            self.assertEqual(err.code, 2, "Invalid value passed")
+        finally:
+            sys.stderr = orig_stderr
+        stderr.seek(0)
+        self.assertIn("argument -n/--build-num: invalid int value: 'N'", 
+                      stderr.read())
+
+    def test_validate_args_run_none_values(self):
+        orig_stderr = sys.stderr
+        stderr = sys.stderr = StringIO()
+        self.publisher = SnapshotsPublisher()
+        try:
+            param = self.parser.parse_args(['-t', None , '-r', None,  
+                                            '-j', None , '-n' , 0])
+            self.publisher.validate_args(param)
+        except SystemExit, err:
+            self.assertEqual(err.code, 2, "None values are not acceptable")
+        finally:
+            sys.stderr = orig_stderr
+        stderr.seek(0)
+        self.assertIn("You must specify job-type and job-name", 
+                      stderr.read())
+
+    def test_validate_paths_invalid_uploads_path(self):
+        orig_stdout = sys.stdout
+        stdout = sys.stdout = StringIO()
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
+                                        '-n', '1'])
+
+        self.publisher.validate_args(param)
+        self.uploads_path = "./dummy_uploads_path"
+        try:
+            self.publisher.validate_paths(param, self.uploads_path, self.target_path)
+        finally:
+            sys.stdout = orig_stdout
+        stdout.seek(0)
+        self.assertIn("Missing build path", stdout.read())
+
+    def test_validate_paths_invalid_target_path(self):
+        orig_stdout = sys.stdout
+        stdout = sys.stdout = StringIO()
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
+                                        '-n', '1'])
+
+        self.publisher.validate_args(param)
+        self.target_path = "./dummy_target_path"
+        try:
+            self.publisher.validate_paths(param, self.uploads_path, 
+                                                        self.target_path)
+        finally:
+            sys.stdout = orig_stdout
+        stdout.seek(0)
+        self.assertIn("Missing target path", stdout.read())
+
+    def test_move_artifacts_kernel_successful_move(self):
+        orig_stdout = sys.stdout
+        stdout = sys.stdout = StringIO()
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'kernel-hwpack', '-j', 'dummy_job_name', 
+                                        '-r', 'dummy_kernel_tree'])
+        self.publisher.validate_args(param)
+        build_path = os.path.join(self.uploads_path, param.job_type, param.kernel_tree, 
+                                  param.job_name)
+        os.makedirs(build_path)
+        tempfiles = tempfile.mkstemp(dir=build_path)
+        try:
+            uploads_dir_path, target_dir_path = self.publisher.validate_paths(param, 
+                                                self.uploads_path, self.target_path)
+            self.publisher.move_artifacts(param, uploads_dir_path, target_dir_path)
+        finally:
+            sys.stdout = orig_stdout
+            pass
+         
+        stdout.seek(0)
+        self.assertIn("Moved the files from", stdout.read())
+
+    def test_move_artifacts_android_successful_move(self):
+        orig_stdout = sys.stdout
+        stdout = sys.stdout = StringIO()
+        self.publisher = SnapshotsPublisher()
+        param = self.parser.parse_args(['-t', 'android', '-j', 'dummy_job_name', 
+                                        '-n', '1'])
+        self.publisher.validate_args(param)
+        build_dir = '/'.join([param.job_type, param.job_name, str(param.build_num)])
+        build_path = os.path.join(self.uploads_path, build_dir)
+        os.makedirs(build_path)
+        tempfiles = tempfile.mkstemp(dir=build_path)
+        try:
+            uploads_dir_path, target_dir_path = self.publisher.validate_paths(param, 
+                                                self.uploads_path, self.target_path)
+            self.publisher.move_artifacts(param, uploads_dir_path, target_dir_path)
+        finally:
+            sys.stdout = orig_stdout
+            pass
+         
+        stdout.seek(0)
+        self.assertIn("Moved the files from", stdout.read())