github.com/10XDev/rclone@v1.52.3-0.20200626220027-16af9ab76b2a/backend/googlephotos/albums_test.go (about)

     1  package googlephotos
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/rclone/rclone/backend/googlephotos/api"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestNewAlbums(t *testing.T) {
    11  	albums := newAlbums()
    12  	assert.NotNil(t, albums.dupes)
    13  	assert.NotNil(t, albums.byID)
    14  	assert.NotNil(t, albums.byTitle)
    15  	assert.NotNil(t, albums.path)
    16  }
    17  
    18  func TestAlbumsAdd(t *testing.T) {
    19  	albums := newAlbums()
    20  
    21  	assert.Equal(t, map[string][]*api.Album{}, albums.dupes)
    22  	assert.Equal(t, map[string]*api.Album{}, albums.byID)
    23  	assert.Equal(t, map[string]*api.Album{}, albums.byTitle)
    24  	assert.Equal(t, map[string][]string{}, albums.path)
    25  
    26  	a1 := &api.Album{
    27  		Title: "one",
    28  		ID:    "1",
    29  	}
    30  	albums.add(a1)
    31  
    32  	assert.Equal(t, map[string][]*api.Album{
    33  		"one": []*api.Album{a1},
    34  	}, albums.dupes)
    35  	assert.Equal(t, map[string]*api.Album{
    36  		"1": a1,
    37  	}, albums.byID)
    38  	assert.Equal(t, map[string]*api.Album{
    39  		"one": a1,
    40  	}, albums.byTitle)
    41  	assert.Equal(t, map[string][]string{
    42  		"": []string{"one"},
    43  	}, albums.path)
    44  
    45  	a2 := &api.Album{
    46  		Title: "two",
    47  		ID:    "2",
    48  	}
    49  	albums.add(a2)
    50  
    51  	assert.Equal(t, map[string][]*api.Album{
    52  		"one": []*api.Album{a1},
    53  		"two": []*api.Album{a2},
    54  	}, albums.dupes)
    55  	assert.Equal(t, map[string]*api.Album{
    56  		"1": a1,
    57  		"2": a2,
    58  	}, albums.byID)
    59  	assert.Equal(t, map[string]*api.Album{
    60  		"one": a1,
    61  		"two": a2,
    62  	}, albums.byTitle)
    63  	assert.Equal(t, map[string][]string{
    64  		"": []string{"one", "two"},
    65  	}, albums.path)
    66  
    67  	// Add a duplicate
    68  	a2a := &api.Album{
    69  		Title: "two",
    70  		ID:    "2a",
    71  	}
    72  	albums.add(a2a)
    73  
    74  	assert.Equal(t, map[string][]*api.Album{
    75  		"one": []*api.Album{a1},
    76  		"two": []*api.Album{a2, a2a},
    77  	}, albums.dupes)
    78  	assert.Equal(t, map[string]*api.Album{
    79  		"1":  a1,
    80  		"2":  a2,
    81  		"2a": a2a,
    82  	}, albums.byID)
    83  	assert.Equal(t, map[string]*api.Album{
    84  		"one":      a1,
    85  		"two {2}":  a2,
    86  		"two {2a}": a2a,
    87  	}, albums.byTitle)
    88  	assert.Equal(t, map[string][]string{
    89  		"": []string{"one", "two {2}", "two {2a}"},
    90  	}, albums.path)
    91  
    92  	// Add a sub directory
    93  	a1sub := &api.Album{
    94  		Title: "one/sub",
    95  		ID:    "1sub",
    96  	}
    97  	albums.add(a1sub)
    98  
    99  	assert.Equal(t, map[string][]*api.Album{
   100  		"one":     []*api.Album{a1},
   101  		"two":     []*api.Album{a2, a2a},
   102  		"one/sub": []*api.Album{a1sub},
   103  	}, albums.dupes)
   104  	assert.Equal(t, map[string]*api.Album{
   105  		"1":    a1,
   106  		"2":    a2,
   107  		"2a":   a2a,
   108  		"1sub": a1sub,
   109  	}, albums.byID)
   110  	assert.Equal(t, map[string]*api.Album{
   111  		"one":      a1,
   112  		"one/sub":  a1sub,
   113  		"two {2}":  a2,
   114  		"two {2a}": a2a,
   115  	}, albums.byTitle)
   116  	assert.Equal(t, map[string][]string{
   117  		"":    []string{"one", "two {2}", "two {2a}"},
   118  		"one": []string{"sub"},
   119  	}, albums.path)
   120  
   121  	// Add a weird path
   122  	a0 := &api.Album{
   123  		Title: "/../././..////.",
   124  		ID:    "0",
   125  	}
   126  	albums.add(a0)
   127  
   128  	assert.Equal(t, map[string][]*api.Album{
   129  		"{0}":     []*api.Album{a0},
   130  		"one":     []*api.Album{a1},
   131  		"two":     []*api.Album{a2, a2a},
   132  		"one/sub": []*api.Album{a1sub},
   133  	}, albums.dupes)
   134  	assert.Equal(t, map[string]*api.Album{
   135  		"0":    a0,
   136  		"1":    a1,
   137  		"2":    a2,
   138  		"2a":   a2a,
   139  		"1sub": a1sub,
   140  	}, albums.byID)
   141  	assert.Equal(t, map[string]*api.Album{
   142  		"{0}":      a0,
   143  		"one":      a1,
   144  		"one/sub":  a1sub,
   145  		"two {2}":  a2,
   146  		"two {2a}": a2a,
   147  	}, albums.byTitle)
   148  	assert.Equal(t, map[string][]string{
   149  		"":    []string{"one", "two {2}", "two {2a}", "{0}"},
   150  		"one": []string{"sub"},
   151  	}, albums.path)
   152  }
   153  
   154  func TestAlbumsDel(t *testing.T) {
   155  	albums := newAlbums()
   156  
   157  	a1 := &api.Album{
   158  		Title: "one",
   159  		ID:    "1",
   160  	}
   161  	albums.add(a1)
   162  
   163  	a2 := &api.Album{
   164  		Title: "two",
   165  		ID:    "2",
   166  	}
   167  	albums.add(a2)
   168  
   169  	// Add a duplicate
   170  	a2a := &api.Album{
   171  		Title: "two",
   172  		ID:    "2a",
   173  	}
   174  	albums.add(a2a)
   175  
   176  	// Add a sub directory
   177  	a1sub := &api.Album{
   178  		Title: "one/sub",
   179  		ID:    "1sub",
   180  	}
   181  	albums.add(a1sub)
   182  
   183  	assert.Equal(t, map[string][]*api.Album{
   184  		"one":     []*api.Album{a1},
   185  		"two":     []*api.Album{a2, a2a},
   186  		"one/sub": []*api.Album{a1sub},
   187  	}, albums.dupes)
   188  	assert.Equal(t, map[string]*api.Album{
   189  		"1":    a1,
   190  		"2":    a2,
   191  		"2a":   a2a,
   192  		"1sub": a1sub,
   193  	}, albums.byID)
   194  	assert.Equal(t, map[string]*api.Album{
   195  		"one":      a1,
   196  		"one/sub":  a1sub,
   197  		"two {2}":  a2,
   198  		"two {2a}": a2a,
   199  	}, albums.byTitle)
   200  	assert.Equal(t, map[string][]string{
   201  		"":    []string{"one", "two {2}", "two {2a}"},
   202  		"one": []string{"sub"},
   203  	}, albums.path)
   204  
   205  	albums.del(a1)
   206  
   207  	assert.Equal(t, map[string][]*api.Album{
   208  		"one":     []*api.Album{a1},
   209  		"two":     []*api.Album{a2, a2a},
   210  		"one/sub": []*api.Album{a1sub},
   211  	}, albums.dupes)
   212  	assert.Equal(t, map[string]*api.Album{
   213  		"2":    a2,
   214  		"2a":   a2a,
   215  		"1sub": a1sub,
   216  	}, albums.byID)
   217  	assert.Equal(t, map[string]*api.Album{
   218  		"one/sub":  a1sub,
   219  		"two {2}":  a2,
   220  		"two {2a}": a2a,
   221  	}, albums.byTitle)
   222  	assert.Equal(t, map[string][]string{
   223  		"":    []string{"one", "two {2}", "two {2a}"},
   224  		"one": []string{"sub"},
   225  	}, albums.path)
   226  
   227  	albums.del(a2)
   228  
   229  	assert.Equal(t, map[string][]*api.Album{
   230  		"one":     []*api.Album{a1},
   231  		"two":     []*api.Album{a2, a2a},
   232  		"one/sub": []*api.Album{a1sub},
   233  	}, albums.dupes)
   234  	assert.Equal(t, map[string]*api.Album{
   235  		"2a":   a2a,
   236  		"1sub": a1sub,
   237  	}, albums.byID)
   238  	assert.Equal(t, map[string]*api.Album{
   239  		"one/sub":  a1sub,
   240  		"two {2a}": a2a,
   241  	}, albums.byTitle)
   242  	assert.Equal(t, map[string][]string{
   243  		"":    []string{"one", "two {2a}"},
   244  		"one": []string{"sub"},
   245  	}, albums.path)
   246  
   247  	albums.del(a2a)
   248  
   249  	assert.Equal(t, map[string][]*api.Album{
   250  		"one":     []*api.Album{a1},
   251  		"two":     []*api.Album{a2, a2a},
   252  		"one/sub": []*api.Album{a1sub},
   253  	}, albums.dupes)
   254  	assert.Equal(t, map[string]*api.Album{
   255  		"1sub": a1sub,
   256  	}, albums.byID)
   257  	assert.Equal(t, map[string]*api.Album{
   258  		"one/sub": a1sub,
   259  	}, albums.byTitle)
   260  	assert.Equal(t, map[string][]string{
   261  		"":    []string{"one"},
   262  		"one": []string{"sub"},
   263  	}, albums.path)
   264  
   265  	albums.del(a1sub)
   266  
   267  	assert.Equal(t, map[string][]*api.Album{
   268  		"one":     []*api.Album{a1},
   269  		"two":     []*api.Album{a2, a2a},
   270  		"one/sub": []*api.Album{a1sub},
   271  	}, albums.dupes)
   272  	assert.Equal(t, map[string]*api.Album{}, albums.byID)
   273  	assert.Equal(t, map[string]*api.Album{}, albums.byTitle)
   274  	assert.Equal(t, map[string][]string{}, albums.path)
   275  }
   276  
   277  func TestAlbumsGet(t *testing.T) {
   278  	albums := newAlbums()
   279  
   280  	a1 := &api.Album{
   281  		Title: "one",
   282  		ID:    "1",
   283  	}
   284  	albums.add(a1)
   285  
   286  	album, ok := albums.get("one")
   287  	assert.Equal(t, true, ok)
   288  	assert.Equal(t, a1, album)
   289  
   290  	album, ok = albums.get("notfound")
   291  	assert.Equal(t, false, ok)
   292  	assert.Nil(t, album)
   293  }
   294  
   295  func TestAlbumsGetDirs(t *testing.T) {
   296  	albums := newAlbums()
   297  
   298  	a1 := &api.Album{
   299  		Title: "one",
   300  		ID:    "1",
   301  	}
   302  	albums.add(a1)
   303  
   304  	dirs, ok := albums.getDirs("")
   305  	assert.Equal(t, true, ok)
   306  	assert.Equal(t, []string{"one"}, dirs)
   307  
   308  	dirs, ok = albums.getDirs("notfound")
   309  	assert.Equal(t, false, ok)
   310  	assert.Nil(t, dirs)
   311  }