cipd: Make it work on Windows.

go/src/infra/tools/cipd/local/fs_test.go

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package local
 
 import (
         "io/ioutil"
         "os"
         "path/filepath"
+        "runtime"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestCwdRelToAbs(t *testing.T) {
         Convey("CwdRelToAbs works", t, func() {
                 fs := tempFileSystem()
                 p, err := fs.CwdRelToAbs(fs.Root())
                 So(err, ShouldBeNil)
@@ skipping 44 matching lines @@
                 So(err, ShouldBeNil)
                 So(p, ShouldEqual, fs.join("y/z"))
                 So(fs.isDir("y/z"), ShouldBeTrue)
                 // Same one.
                 _, err = fs.EnsureDirectory(fs.join("x/../y/z"))
                 So(err, ShouldBeNil)
         })
 }
 
 func TestEnsureSymlink(t *testing.T) {
+        if runtime.GOOS == "windows" {
+                t.Skip("Skipping on Windows: no symlinks")
+        }
+
         Convey("EnsureSymlink checks root", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureSymlink(fs.join(".."), fs.Root()), ShouldNotBeNil)
         })
 
-        Convey("ensureSymlink creates new symlink", t, func() {
+        Convey("EnsureSymlink creates new symlink", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureSymlink(fs.join("symlink"), "target"), ShouldBeNil)
                 So(fs.readLink("symlink"), ShouldEqual, "target")
         })
 
-        Convey("ensureSymlink builds full path", t, func() {
+        Convey("EnsureSymlink builds full path", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureSymlink(fs.join("a/b/c"), "target"), ShouldBeNil)
                 So(fs.readLink("a/b/c"), ShouldEqual, "target")
         })
 
-        Convey("ensureSymlink replaces existing one", t, func() {
+        Convey("EnsureSymlink replaces existing symlink", t, func() {
                 fs := tempFileSystem()
                 // Replace with same one, then with another one.
                 So(fs.EnsureSymlink(fs.join("symlink"), "target"), ShouldBeNil)
                 So(fs.EnsureSymlink(fs.join("symlink"), "target"), ShouldBeNil)
                 So(fs.EnsureSymlink(fs.join("symlink"), "another"), ShouldBeNil)
                 So(fs.readLink("symlink"), ShouldEqual, "another")
         })
+
+        Convey("EnsureSymlink replaces existing file", t, func() {
+                fs := tempFileSystem()
+                fs.write("path", "blah")
+                So(fs.EnsureSymlink(fs.join("path"), "target"), ShouldBeNil)
+                So(fs.readLink("path"), ShouldEqual, "target")
+        })
+
+        Convey("EnsureSymlink replaces existing directory", t, func() {
+                fs := tempFileSystem()
+                fs.write("a/b/c", "something")
+                So(fs.EnsureSymlink(fs.join("a"), "target"), ShouldBeNil)
+                So(fs.readLink("a"), ShouldEqual, "target")
+        })
+}
+
+func TestEnsureFile(t *testing.T) {
+        Convey("EnsureFile checks root", t, func() {
+                fs := tempFileSystem()
+                So(fs.EnsureFile(fs.join(".."), []byte("blah"), 0666), ShouldNotBeNil)
+        })
+
+        Convey("EnsureFile creates new file", t, func() {
+                fs := tempFileSystem()
+                So(fs.EnsureFile(fs.join("name"), []byte("blah"), 0666), ShouldBeNil)
+                So(fs.read("name"), ShouldEqual, "blah")
+        })
+
+        Convey("EnsureFile builds full path", t, func() {
+                fs := tempFileSystem()
+                So(fs.EnsureFile(fs.join("a/b/c"), []byte("blah"), 0666), ShouldBeNil)
+                So(fs.read("a/b/c"), ShouldEqual, "blah")
+        })
+
+        if runtime.GOOS != "windows" {
+                Convey("EnsureFile replaces existing symlink", t, func() {
+                        fs := tempFileSystem()
+                        So(fs.EnsureSymlink(fs.join("path"), "target"), ShouldBeNil)
+                        So(fs.EnsureFile(fs.join("path"), []byte("blah"), 0666), ShouldBeNil)
+                        So(fs.read("path"), ShouldEqual, "blah")
+                })
+        }
+
+        Convey("EnsureFile replaces existing file", t, func() {
+                fs := tempFileSystem()
+                So(fs.EnsureFile(fs.join("path"), []byte("huh"), 0666), ShouldBeNil)
+                So(fs.EnsureFile(fs.join("path"), []byte("blah"), 0666), ShouldBeNil)
+                So(fs.read("path"), ShouldEqual, "blah")
+        })
+
+        Convey("EnsureFile replaces existing directory", t, func() {
+                fs := tempFileSystem()
+                fs.write("a/b/c", "something")
+                So(fs.EnsureFile(fs.join("a"), []byte("blah"), 0666), ShouldBeNil)
+                So(fs.read("a"), ShouldEqual, "blah")
+        })
 }
 
 func TestEnsureFileGone(t *testing.T) {
         Convey("EnsureFileGone checks root", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureFileGone(fs.join("../abc")), ShouldNotBeNil)
         })
 
         Convey("EnsureFileGone works", t, func() {
                 fs := tempFileSystem()
                 fs.write("abc", "")
                 So(fs.EnsureFileGone(fs.join("abc")), ShouldBeNil)
                 So(fs.isMissing("abc"), ShouldBeTrue)
         })
 
         Convey("EnsureFileGone works with missing file", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureFileGone(fs.join("abc")), ShouldBeNil)
         })
 
-        Convey("EnsureFileGone works with symlink", t, func() {
-                fs := tempFileSystem()
-                So(fs.EnsureSymlink(fs.join("abc"), "target"), ShouldBeNil)
-                So(fs.EnsureFileGone(fs.join("abc")), ShouldBeNil)
-                So(fs.isMissing("abc"), ShouldBeTrue)
-        })
+        if runtime.GOOS != "windows" {
+                Convey("EnsureFileGone works with symlink", t, func() {
+                        fs := tempFileSystem()
+                        So(fs.EnsureSymlink(fs.join("abc"), "target"), ShouldBeNil)
+                        So(fs.EnsureFileGone(fs.join("abc")), ShouldBeNil)
+                        So(fs.isMissing("abc"), ShouldBeTrue)
+                })
+        }
 }
 
 func TestEnsureDirectoryGone(t *testing.T) {
         Convey("EnsureDirectoryGone checks root", t, func() {
                 fs := tempFileSystem()
                 So(fs.EnsureDirectoryGone(fs.join("../abc")), ShouldNotBeNil)
         })
 
         Convey("EnsureDirectoryGone works", t, func() {
                 fs := tempFileSystem()
@@ skipping 157 matching lines @@
 
 // isFile returns true if a file at a given slash separated path relative to
 // Root() is a file (not a directory).
 func (f *tempFileSystemImpl) isFile(rel string) bool {
         stat, err := os.Stat(f.join(rel))
         if err != nil {
                 return false
         }
         return !stat.IsDir()
 }