Compare commits
No commits in common. "3d18392b673e66fe04b5da91e7aed67658fdc082" and "10a83d36f7daca1e9c44e220c66af61b4bd011ae" have entirely different histories.
3d18392b67
...
10a83d36f7
2
Pipfile
2
Pipfile
|
@ -25,4 +25,4 @@ sphinxcontrib-blockdiag = "*"
|
|||
pylama = "*"
|
||||
|
||||
[requires]
|
||||
python_version = "3.6"
|
||||
python_version = "3.5"
|
||||
|
|
212
Pipfile.lock
generated
212
Pipfile.lock
generated
|
@ -1,11 +1,11 @@
|
|||
{
|
||||
"_meta": {
|
||||
"hash": {
|
||||
"sha256": "8a774f3325746a2eb48dfd94b9af22cbb8668b33e267391c64e8e295cee63b72"
|
||||
"sha256": "3b941559bcaf1c164285aef53553496fbf1414f362da1433b705ac7c796e33e6"
|
||||
},
|
||||
"pipfile-spec": 6,
|
||||
"requires": {
|
||||
"python_version": "3.6"
|
||||
"python_version": "3.5"
|
||||
},
|
||||
"sources": [
|
||||
{
|
||||
|
@ -18,10 +18,10 @@
|
|||
"default": {
|
||||
"amqp": {
|
||||
"hashes": [
|
||||
"sha256:9f181e4aef6562e6f9f45660578fc1556150ca06e836ecb9e733e6ea10b48464",
|
||||
"sha256:c3d7126bfbc640d076a01f1f4f6e609c0e4348508150c1f61336b0d83c738d2b"
|
||||
"sha256:073dd02fdd73041bffc913b767866015147b61f2a9bc104daef172fc1a0066eb",
|
||||
"sha256:eed41946890cd43e8dee44a316b85cf6fee5a1a34bb4a562b660a358eb529e1b"
|
||||
],
|
||||
"version": "==2.4.0"
|
||||
"version": "==2.3.2"
|
||||
},
|
||||
"billiard": {
|
||||
"hashes": [
|
||||
|
@ -60,11 +60,11 @@
|
|||
},
|
||||
"django": {
|
||||
"hashes": [
|
||||
"sha256:a32c22af23634e1d11425574dce756098e015a165be02e4690179889b207c7a8",
|
||||
"sha256:d6393918da830530a9516bbbcbf7f1214c3d733738779f06b0f649f49cc698c3"
|
||||
"sha256:068d51054083d06ceb32ce02b7203f1854256047a0d58682677dd4f81bceabd7",
|
||||
"sha256:55409a056b27e6d1246f19ede41c6c610e4cab549c005b62cbeefabc6433356b"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==2.1.5"
|
||||
"version": "==2.1.4"
|
||||
},
|
||||
"django-allauth": {
|
||||
"hashes": [
|
||||
|
@ -110,17 +110,17 @@
|
|||
},
|
||||
"kombu": {
|
||||
"hashes": [
|
||||
"sha256:1ef049243aa05f29e988ab33444ec7f514375540eaa8e0b2e1f5255e81c5e56d",
|
||||
"sha256:3c9dca2338c5d893f30c151f5d29bfb81196748ab426d33c362ab51f1e8dbf78"
|
||||
"sha256:52763f41077e25fe7e2f17b8319d8a7b7ab953a888c49d9e4e0464fceb716896",
|
||||
"sha256:9bf7d37b93249b76a03afb7bbcf7149a358b6079ca2431e725414b1caa10922c"
|
||||
],
|
||||
"version": "==4.2.2.post1"
|
||||
"version": "==4.2.2"
|
||||
},
|
||||
"oauthlib": {
|
||||
"hashes": [
|
||||
"sha256:0ce32c5d989a1827e3f1148f98b9085ed2370fc939bf524c9c851d8714797298",
|
||||
"sha256:3e1e14f6cde7e5475128d30e97edc3bfb4dc857cb884d8714ec161fdbb3b358e"
|
||||
"sha256:ac35665a61c1685c56336bda97d5eefa246f1202618a1d6f34fccb1bdd404162",
|
||||
"sha256:d883b36b21a6ad813953803edfa563b1b579d79ca758fe950d1bc9e8b326025b"
|
||||
],
|
||||
"version": "==3.0.1"
|
||||
"version": "==2.1.0"
|
||||
},
|
||||
"passlib": {
|
||||
"hashes": [
|
||||
|
@ -132,39 +132,39 @@
|
|||
},
|
||||
"psycopg2": {
|
||||
"hashes": [
|
||||
"sha256:02445ebbb3a11a3fe8202c413d5e6faf38bb75b4e336203ee144ca2c46529f94",
|
||||
"sha256:0e9873e60f98f0c52339abf8f0339d1e22bfe5aae0bcf7aabd40c055175035ec",
|
||||
"sha256:1148a5eb29073280bf9057c7fc45468592c1bb75a28f6df1591adb93c8cb63d0",
|
||||
"sha256:259a8324e109d4922b0fcd046e223e289830e2568d6f4132a3702439e5fd532b",
|
||||
"sha256:28dffa9ed4595429e61bacac41d3f9671bb613d1442ff43bcbec63d4f73ed5e8",
|
||||
"sha256:314a74302d4737a3865d40ea50e430ce1543c921ba10f39d562e807cfe2edf2a",
|
||||
"sha256:36b60201b6d215d7658a71493fdf6bd5e60ad9a0cffed39906627ff9f4f3afd3",
|
||||
"sha256:3f9d532bce54c4234161176ff3b8688ff337575ca441ea27597e112dfcd0ee0c",
|
||||
"sha256:5d222983847b40af989ad96c07fc3f07e47925e463baa5de716be8f805b41d9b",
|
||||
"sha256:6757a6d2fc58f7d8f5d471ad180a0bd7b4dd3c7d681f051504fbea7ae29c8d6f",
|
||||
"sha256:6a0e0f1e74edb0ab57d89680e59e7bfefad2bfbdf7c80eb38304d897d43674bb",
|
||||
"sha256:6ca703ccdf734e886a1cf53eb702261110f6a8b0ed74bcad15f1399f74d3f189",
|
||||
"sha256:8513b953d8f443c446aa79a4cc8a898bd415fc5e29349054f03a7d696d495542",
|
||||
"sha256:9262a5ce2038570cb81b4d6413720484cb1bc52c064b2f36228d735b1f98b794",
|
||||
"sha256:97441f851d862a0c844d981cbee7ee62566c322ebb3d68f86d66aa99d483985b",
|
||||
"sha256:a07feade155eb8e69b54dd6774cf6acf2d936660c61d8123b8b6b1f9247b67d6",
|
||||
"sha256:a9b9c02c91b1e3ec1f1886b2d0a90a0ea07cc529cb7e6e472b556bc20ce658f3",
|
||||
"sha256:ae88216f94728d691b945983140bf40d51a1ff6c7fe57def93949bf9339ed54a",
|
||||
"sha256:b360ffd17659491f1a6ad7c928350e229c7b7bd83a2b922b6ee541245c7a776f",
|
||||
"sha256:b4221957ceccf14b2abdabef42d806e791350be10e21b260d7c9ce49012cc19e",
|
||||
"sha256:b90758e49d5e6b152a460d10b92f8a6ccf318fcc0ee814dcf53f3a6fc5328789",
|
||||
"sha256:c669ea986190ed05fb289d0c100cc88064351f2b85177cbfd3564c4f4847d18c",
|
||||
"sha256:d1b61999d15c79cf7f4f7cc9021477aef35277fc52452cf50fd13b713c84424d",
|
||||
"sha256:de7bb043d1adaaf46e38d47e7a5f703bb3dab01376111e522b07d25e1a79c1e1",
|
||||
"sha256:e393568e288d884b94d263f2669215197840d097c7e5b0acd1a51c1ea7d1aba8",
|
||||
"sha256:ed7e0849337bd37d89f2c2b0216a0de863399ee5d363d31b1e5330a99044737b",
|
||||
"sha256:f153f71c3164665d269a5d03c7fa76ba675c7a8de9dc09a4e2c2cdc9936a7b41",
|
||||
"sha256:f1fb5a8427af099beb7f65093cbdb52e021b8e6dbdfaf020402a623f4181baf5",
|
||||
"sha256:f36b333e9f86a2fba960c72b90c34be6ca71819e300f7b1fc3d2b0f0b2c546cd",
|
||||
"sha256:f4526d078aedd5187d0508aa5f9a01eae6a48a470ed678406da94b4cd6524b7e"
|
||||
"sha256:10e391687b171878181e71736d0effe3772314a339d9ae30995ec8171a0c834e",
|
||||
"sha256:1283f9d45e458c2dcb15ba89367923563f90ef636fe78ee22df75183484a0237",
|
||||
"sha256:1a9c32e4d140bea225f9821d993b2e53c913e717ea97b851246aa9b300095d8f",
|
||||
"sha256:1be6f2438d2b71fec7b07c3c0949dd321b04349c382907ea76b36120edec8300",
|
||||
"sha256:20ca6f29e118b8dd7133e8708b3fba2881e70a4e0841f874ed23985b7201a076",
|
||||
"sha256:227c115b3c1f65d61385e51ac690b91b584640aefb45bffacd4bd33d02ed7221",
|
||||
"sha256:27959abe64ca1fc6d8cd11a71a1f421d8287831a3262bd4cacd43bbf43cc3c82",
|
||||
"sha256:2b2daf1fe30a58300542aea679fd87d1e1c2afd36e7644837b7954fa2dbacb92",
|
||||
"sha256:36e51a51f295fdf67bcf05e7b1877011a6b39e6622b0013fe31c5025241873a3",
|
||||
"sha256:3992b9b914f2eb77dc07e8045d2ca979e491612808bc5c7cd68f307469acf9f6",
|
||||
"sha256:39a11de2335ad45ececed43ab851d36a4c52843d756471b940804f301792781e",
|
||||
"sha256:3c2afe9ef0d1649005e3ccf93c1aaccd6f8ee379530e763d3b3b77f406b7c0ae",
|
||||
"sha256:3fb18e0e52807fe3a300dc1b5421aa492d5e759550918f597d61863419482535",
|
||||
"sha256:55eab94de96ee9702f23283e9c8b03cfdb0001e2b14d5d2e1bd5ff8114b96b9f",
|
||||
"sha256:7e95c0ab7e7e6e452586f35d4d8966b1e924c8dd2c23977e3ea4968770ff1d26",
|
||||
"sha256:7f47514dbddf604f196fcfe5da955537f04691bef8124aff5632316a78d992b7",
|
||||
"sha256:8345370356bb4bddf93acbcfd0357163dd6b09471937adcfb38a2fbb49bdce53",
|
||||
"sha256:8bc6ecb220c0b88d3742042013129c817c44459795c97e9ce1bca70a3f37a53b",
|
||||
"sha256:8df623f248be15d1725faf5f333791678775047f12f17a90d29b5d22573f5cdc",
|
||||
"sha256:9645f1305e4268cc0fc88c823cd6c91de27c003e183c233a6a230e5e963039ee",
|
||||
"sha256:a68719ed5be8373dd72c9e45d55f7a202285e05a2e392eaa8872a67ea47d7d20",
|
||||
"sha256:aca0edf062ec09e954fdf0cc93d3a872362701210983a1442549e703aedec25d",
|
||||
"sha256:b0dd2114d93d8f424bb8ae76e0dc540f104b70ca9163172c05e7700b1459d4c9",
|
||||
"sha256:b2c09359d6802279efb9efb3f91a9c94567151baee95175f9b637ea628f35244",
|
||||
"sha256:ca7bc37b1efb7cc25271bf10f398462ed975d95259af1406d38fcb268466e34f",
|
||||
"sha256:e64235d9013ebf6319cb9654e08f5066112c34d8c4cc41186254ab9c3d6d5b9b",
|
||||
"sha256:ec9be679c0065667503851141c31fa699e1cc69ded3ba8e5d3673dd5a6eb1370",
|
||||
"sha256:eca00d0f91fcb44d88b12f1fd16ad138e38fa07debb79587e2b7ff1fe80d72b9",
|
||||
"sha256:f256e807b8b2b45b6af60d7f2bb5194aab2f4acc861241c4d8ef942a55f5030d",
|
||||
"sha256:fce7612a3bd6a7ba95799f88285653bf130bd7ca066b52674d5f850108b2aec0"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==2.7.7"
|
||||
"version": "==2.7.6.1"
|
||||
},
|
||||
"python3-openid": {
|
||||
"hashes": [
|
||||
|
@ -175,18 +175,18 @@
|
|||
},
|
||||
"pytz": {
|
||||
"hashes": [
|
||||
"sha256:32b0891edff07e28efe91284ed9c31e123d84bea3fd98e1f72be2508f43ef8d9",
|
||||
"sha256:d5f05e487007e29e03409f9398d074e158d920d36eb82eaf66fb1136b0c5374c"
|
||||
"sha256:31cb35c89bd7d333cd32c5f278fca91b523b0834369e757f4c5641ea252236ca",
|
||||
"sha256:8e0f8568c118d3077b46be7d654cc8167fa916092e28320cde048e54bfc9f1e6"
|
||||
],
|
||||
"version": "==2018.9"
|
||||
"version": "==2018.7"
|
||||
},
|
||||
"redis": {
|
||||
"hashes": [
|
||||
"sha256:74c892041cba46078ae1ef845241548baa3bd3634f9a6f0f952f006eb1619c71",
|
||||
"sha256:7ba8612bbfd966dea8c62322543fed0095da2834dbd5a7c124afbc617a156aa7"
|
||||
"sha256:2100750629beff143b6a200a2ea8e719fcf26420adabb81402895e144c5083cf",
|
||||
"sha256:8e0bdd2de02e829b6225b25646f9fb9daffea99a252610d040409a6738541f0a"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==3.1.0"
|
||||
"version": "==3.0.1"
|
||||
},
|
||||
"requests": {
|
||||
"hashes": [
|
||||
|
@ -197,11 +197,11 @@
|
|||
},
|
||||
"requests-oauthlib": {
|
||||
"hashes": [
|
||||
"sha256:bd6533330e8748e94bf0b214775fed487d309b8b8fe823dc45641ebcd9a32f57",
|
||||
"sha256:d3ed0c8f2e3bbc6b344fa63d6f933745ab394469da38db16bdddb461c7e25140"
|
||||
"sha256:8886bfec5ad7afb391ed5443b1f697c6f4ae98d0e5620839d8b4499c032ada3f",
|
||||
"sha256:e21232e2465808c0e892e0e4dbb8c2faafec16ac6dc067dd546e9b466f3deac8"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==1.2.0"
|
||||
"version": "==1.0.0"
|
||||
},
|
||||
"urllib3": {
|
||||
"hashes": [
|
||||
|
@ -212,10 +212,10 @@
|
|||
},
|
||||
"vine": {
|
||||
"hashes": [
|
||||
"sha256:3cd505dcf980223cfaf13423d371f2e7ff99247e38d5985a01ec8264e4f2aca1",
|
||||
"sha256:ee4813e915d0e1a54e5c1963fde0855337f82655678540a6bc5996bca4165f76"
|
||||
"sha256:52116d59bc45392af9fdd3b75ed98ae48a93e822cee21e5fda249105c59a7a72",
|
||||
"sha256:6849544be74ec3638e84d90bc1cf2e1e9224cc10d96cd4383ec3f69e9bce077b"
|
||||
],
|
||||
"version": "==1.2.0"
|
||||
"version": "==1.1.4"
|
||||
}
|
||||
},
|
||||
"develop": {
|
||||
|
@ -293,11 +293,11 @@
|
|||
},
|
||||
"django": {
|
||||
"hashes": [
|
||||
"sha256:a32c22af23634e1d11425574dce756098e015a165be02e4690179889b207c7a8",
|
||||
"sha256:d6393918da830530a9516bbbcbf7f1214c3d733738779f06b0f649f49cc698c3"
|
||||
"sha256:068d51054083d06ceb32ce02b7203f1854256047a0d58682677dd4f81bceabd7",
|
||||
"sha256:55409a056b27e6d1246f19ede41c6c610e4cab549c005b62cbeefabc6433356b"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==2.1.5"
|
||||
"version": "==2.1.4"
|
||||
},
|
||||
"django-debug-toolbar": {
|
||||
"hashes": [
|
||||
|
@ -384,52 +384,52 @@
|
|||
},
|
||||
"packaging": {
|
||||
"hashes": [
|
||||
"sha256:0c98a5d0be38ed775798ece1b9727178c4469d9c3b4ada66e8e6b7849f8732af",
|
||||
"sha256:9e1cbf8c12b1f1ce0bb5344b8d7ecf66a6f8a6e91bcb0c84593ed6d3ab5c4ab3"
|
||||
"sha256:0886227f54515e592aaa2e5a553332c73962917f2831f1b0f9b9f4380a4b9807",
|
||||
"sha256:f95a1e147590f204328170981833854229bb2912ac3d5f89e2a8ccd2834800c9"
|
||||
],
|
||||
"version": "==19.0"
|
||||
"version": "==18.0"
|
||||
},
|
||||
"pillow": {
|
||||
"hashes": [
|
||||
"sha256:051de330a06c99d6f84bcf582960487835bcae3fc99365185dc2d4f65a390c0e",
|
||||
"sha256:0ae5289948c5e0a16574750021bd8be921c27d4e3527800dc9c2c1d2abc81bf7",
|
||||
"sha256:0b1efce03619cdbf8bcc61cfae81fcda59249a469f31c6735ea59badd4a6f58a",
|
||||
"sha256:163136e09bd1d6c6c6026b0a662976e86c58b932b964f255ff384ecc8c3cefa3",
|
||||
"sha256:18e912a6ccddf28defa196bd2021fe33600cbe5da1aa2f2e2c6df15f720b73d1",
|
||||
"sha256:24ec3dea52339a610d34401d2d53d0fb3c7fd08e34b20c95d2ad3973193591f1",
|
||||
"sha256:267f8e4c0a1d7e36e97c6a604f5b03ef58e2b81c1becb4fccecddcb37e063cc7",
|
||||
"sha256:3273a28734175feebbe4d0a4cde04d4ed20f620b9b506d26f44379d3c72304e1",
|
||||
"sha256:4c678e23006798fc8b6f4cef2eaad267d53ff4c1779bd1af8725cc11b72a63f3",
|
||||
"sha256:4d4bc2e6bb6861103ea4655d6b6f67af8e5336e7216e20fff3e18ffa95d7a055",
|
||||
"sha256:505738076350a337c1740a31646e1de09a164c62c07db3b996abdc0f9d2e50cf",
|
||||
"sha256:5233664eadfa342c639b9b9977190d64ad7aca4edc51a966394d7e08e7f38a9f",
|
||||
"sha256:5d95cb9f6cced2628f3e4de7e795e98b2659dfcc7176ab4a01a8b48c2c2f488f",
|
||||
"sha256:7eda4c737637af74bac4b23aa82ea6fbb19002552be85f0b89bc27e3a762d239",
|
||||
"sha256:801ddaa69659b36abf4694fed5aa9f61d1ecf2daaa6c92541bbbbb775d97b9fe",
|
||||
"sha256:825aa6d222ce2c2b90d34a0ea31914e141a85edefc07e17342f1d2fdf121c07c",
|
||||
"sha256:9c215442ff8249d41ff58700e91ef61d74f47dfd431a50253e1a1ca9436b0697",
|
||||
"sha256:a3d90022f2202bbb14da991f26ca7a30b7e4c62bf0f8bf9825603b22d7e87494",
|
||||
"sha256:a631fd36a9823638fe700d9225f9698fb59d049c942d322d4c09544dc2115356",
|
||||
"sha256:a6523a23a205be0fe664b6b8747a5c86d55da960d9586db039eec9f5c269c0e6",
|
||||
"sha256:a756ecf9f4b9b3ed49a680a649af45a8767ad038de39e6c030919c2f443eb000",
|
||||
"sha256:b117287a5bdc81f1bac891187275ec7e829e961b8032c9e5ff38b70fd036c78f",
|
||||
"sha256:ba04f57d1715ca5ff74bb7f8a818bf929a204b3b3c2c2826d1e1cc3b1c13398c",
|
||||
"sha256:cd878195166723f30865e05d87cbaf9421614501a4bd48792c5ed28f90fd36ca",
|
||||
"sha256:cee815cc62d136e96cf76771b9d3eb58e0777ec18ea50de5cfcede8a7c429aa8",
|
||||
"sha256:d1722b7aa4b40cf93ac3c80d3edd48bf93b9208241d166a14ad8e7a20ee1d4f3",
|
||||
"sha256:d7c1c06246b05529f9984435fc4fa5a545ea26606e7f450bdbe00c153f5aeaad",
|
||||
"sha256:e9c8066249c040efdda84793a2a669076f92a301ceabe69202446abb4c5c5ef9",
|
||||
"sha256:f227d7e574d050ff3996049e086e1f18c7bd2d067ef24131e50a1d3fe5831fbc",
|
||||
"sha256:fc9a12aad714af36cf3ad0275a96a733526571e52710319855628f476dcb144e"
|
||||
"sha256:00203f406818c3f45d47bb8fe7e67d3feddb8dcbbd45a289a1de7dd789226360",
|
||||
"sha256:0616f800f348664e694dddb0b0c88d26761dd5e9f34e1ed7b7a7d2da14b40cb7",
|
||||
"sha256:1f7908aab90c92ad85af9d2fec5fc79456a89b3adcc26314d2cde0e238bd789e",
|
||||
"sha256:2ea3517cd5779843de8a759c2349a3cd8d3893e03ab47053b66d5ec6f8bc4f93",
|
||||
"sha256:48a9f0538c91fc136b3a576bee0e7cd174773dc9920b310c21dcb5519722e82c",
|
||||
"sha256:5280ebc42641a1283b7b1f2c20e5b936692198b9dd9995527c18b794850be1a8",
|
||||
"sha256:5e34e4b5764af65551647f5cc67cf5198c1d05621781d5173b342e5e55bf023b",
|
||||
"sha256:63b120421ab85cad909792583f83b6ca3584610c2fe70751e23f606a3c2e87f0",
|
||||
"sha256:696b5e0109fe368d0057f484e2e91717b49a03f1e310f857f133a4acec9f91dd",
|
||||
"sha256:870ed021a42b1b02b5fe4a739ea735f671a84128c0a666c705db2cb9abd528eb",
|
||||
"sha256:916da1c19e4012d06a372127d7140dae894806fad67ef44330e5600d77833581",
|
||||
"sha256:9303a289fa0811e1c6abd9ddebfc770556d7c3311cb2b32eff72164ddc49bc64",
|
||||
"sha256:9577888ecc0ad7d06c3746afaba339c94d62b59da16f7a5d1cff9e491f23dace",
|
||||
"sha256:987e1c94a33c93d9b209315bfda9faa54b8edfce6438a1e93ae866ba20de5956",
|
||||
"sha256:99a3bbdbb844f4fb5d6dd59fac836a40749781c1fa63c563bc216c27aef63f60",
|
||||
"sha256:99db8dc3097ceafbcff9cb2bff384b974795edeb11d167d391a02c7bfeeb6e16",
|
||||
"sha256:a5a96cf49eb580756a44ecf12949e52f211e20bffbf5a95760ac14b1e499cd37",
|
||||
"sha256:aa6ca3eb56704cdc0d876fc6047ffd5ee960caad52452fbee0f99908a141a0ae",
|
||||
"sha256:aade5e66795c94e4a2b2624affeea8979648d1b0ae3fcee17e74e2c647fc4a8a",
|
||||
"sha256:b78905860336c1d292409e3df6ad39cc1f1c7f0964e66844bbc2ebfca434d073",
|
||||
"sha256:b92f521cdc4e4a3041cc343625b699f20b0b5f976793fb45681aac1efda565f8",
|
||||
"sha256:bfde84bbd6ae5f782206d454b67b7ee8f7f818c29b99fd02bf022fd33bab14cb",
|
||||
"sha256:c2b62d3df80e694c0e4a0ed47754c9480521e25642251b3ab1dff050a4e60409",
|
||||
"sha256:c5e2be6c263b64f6f7656e23e18a4a9980cffc671442795682e8c4e4f815dd9f",
|
||||
"sha256:c99aa3c63104e0818ec566f8ff3942fb7c7a8f35f9912cb63fd8e12318b214b2",
|
||||
"sha256:dae06620d3978da346375ebf88b9e2dd7d151335ba668c995aea9ed07af7add4",
|
||||
"sha256:db5499d0710823fa4fb88206050d46544e8f0e0136a9a5f5570b026584c8fd74",
|
||||
"sha256:f36baafd82119c4a114b9518202f2a983819101dcc14b26e43fc12cbefdce00e",
|
||||
"sha256:f52b79c8796d81391ab295b04e520bda6feed54d54931708872e8f9ae9db0ea1",
|
||||
"sha256:ff8cff01582fa1a7e533cb97f628531c4014af4b5f38e33cdcfe5eec29b6d888"
|
||||
],
|
||||
"version": "==5.4.1"
|
||||
"version": "==5.3.0"
|
||||
},
|
||||
"pycodestyle": {
|
||||
"hashes": [
|
||||
"sha256:95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56",
|
||||
"sha256:e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"
|
||||
"sha256:cbc619d09254895b0d12c2c691e237b2e91e9b2ecf5e84c26b35400f93dcfb83",
|
||||
"sha256:cbfca99bd594a10f674d0cd97a3d802a1fdef635d4361e1a2658de47ed261e3a"
|
||||
],
|
||||
"version": "==2.5.0"
|
||||
"version": "==2.4.0"
|
||||
},
|
||||
"pydocstyle": {
|
||||
"hashes": [
|
||||
|
@ -441,10 +441,10 @@
|
|||
},
|
||||
"pyflakes": {
|
||||
"hashes": [
|
||||
"sha256:5e8c00e30c464c99e0b501dc160b13a14af7f27d4dffb529c556e30a159e231d",
|
||||
"sha256:f277f9ca3e55de669fba45b7393a1449009cff5a37d1af10ebb76c52765269cd"
|
||||
"sha256:9a7662ec724d0120012f6e29d6248ae3727d821bba522a0e6b356eff19126a49",
|
||||
"sha256:f661252913bc1dbe7fcfcbf0af0db3f42ab65aabd1a6ca68fe5d466bace94dae"
|
||||
],
|
||||
"version": "==2.1.0"
|
||||
"version": "==2.0.0"
|
||||
},
|
||||
"pygments": {
|
||||
"hashes": [
|
||||
|
@ -463,17 +463,17 @@
|
|||
},
|
||||
"pyparsing": {
|
||||
"hashes": [
|
||||
"sha256:66c9268862641abcac4a96ba74506e594c884e3f57690a696d21ad8210ed667a",
|
||||
"sha256:f6c5ef0d7480ad048c054c37632c67fca55299990fff127850181659eea33fc3"
|
||||
"sha256:40856e74d4987de5d01761a22d1621ae1c7f8774585acae358aa5c5936c6c90b",
|
||||
"sha256:f353aab21fd474459d97b709e527b5571314ee5f067441dc9f88e33eecd96592"
|
||||
],
|
||||
"version": "==2.3.1"
|
||||
"version": "==2.3.0"
|
||||
},
|
||||
"pytz": {
|
||||
"hashes": [
|
||||
"sha256:32b0891edff07e28efe91284ed9c31e123d84bea3fd98e1f72be2508f43ef8d9",
|
||||
"sha256:d5f05e487007e29e03409f9398d074e158d920d36eb82eaf66fb1136b0c5374c"
|
||||
"sha256:31cb35c89bd7d333cd32c5f278fca91b523b0834369e757f4c5641ea252236ca",
|
||||
"sha256:8e0f8568c118d3077b46be7d654cc8167fa916092e28320cde048e54bfc9f1e6"
|
||||
],
|
||||
"version": "==2018.9"
|
||||
"version": "==2018.7"
|
||||
},
|
||||
"releases": {
|
||||
"hashes": [
|
||||
|
|
|
@ -35,4 +35,28 @@ The project module :py:mod:`gnuviechadmin`
|
|||
-------------------------------------------
|
||||
|
||||
.. automodule:: gnuviechadmin.settings
|
||||
|
||||
|
||||
:py:mod:`base <gnuviechadmin.settings.base>`
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. automodule:: gnuviechadmin.settings.base
|
||||
:members:
|
||||
|
||||
|
||||
:py:mod:`local <gnuviechadmin.settings.local>`
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. automodule:: gnuviechadmin.settings.local
|
||||
|
||||
|
||||
:py:mod:`production <gnuviechadmin.settings.production>`
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. automodule:: gnuviechadmin.settings.production
|
||||
|
||||
|
||||
:py:mod:`test <gnuviechadmin.settings.test>`
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. automodule:: gnuviechadmin.settings.test
|
||||
|
|
|
@ -2,18 +2,26 @@
|
|||
Tests for :py:mod:`contact_form.forms`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from django.contrib.sites.models import Site
|
||||
import mock
|
||||
from mock import MagicMock, Mock
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
from django.contrib.sites.models import Site
|
||||
|
||||
from contact_form.forms import ContactForm
|
||||
|
||||
TEST_DATA = {"name": "Test User", "email": "test@example.org", "body": "Test message"}
|
||||
TEST_DATA = {
|
||||
'name': 'Test User',
|
||||
'email': 'test@example.org',
|
||||
'body': 'Test message'
|
||||
}
|
||||
|
||||
|
||||
class ContactFormTest(TestCase):
|
||||
|
||||
def test_constructor_needs_request(self):
|
||||
with self.assertRaises(KeyError):
|
||||
ContactForm()
|
||||
|
@ -21,63 +29,63 @@ class ContactFormTest(TestCase):
|
|||
def test_constructor(self):
|
||||
request = MagicMock()
|
||||
form = ContactForm(request=request)
|
||||
self.assertTrue(hasattr(form, "request"))
|
||||
self.assertTrue(hasattr(form, 'request'))
|
||||
self.assertEqual(form.request, request)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(form.helper.form_action, reverse("contact_form"))
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse('contact_form'))
|
||||
self.assertEqual(len(form.helper.inputs), 1)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
def test_constructor_fields(self):
|
||||
request = MagicMock()
|
||||
form = ContactForm(request=request)
|
||||
self.assertEqual(len(form.fields), 3)
|
||||
self.assertIn("email", form.fields)
|
||||
self.assertIn("name", form.fields)
|
||||
self.assertIn("body", form.fields)
|
||||
self.assertIn('email', form.fields)
|
||||
self.assertIn('name', form.fields)
|
||||
self.assertIn('body', form.fields)
|
||||
self.assertEqual(len(form.data), 0)
|
||||
|
||||
def test_get_context_invalid(self):
|
||||
request = MagicMock()
|
||||
form = ContactForm(request=request)
|
||||
with self.assertRaisesMessage(
|
||||
ValueError, "Cannot generate context from invalid contact form"
|
||||
):
|
||||
ValueError,
|
||||
'Cannot generate context from invalid contact form'):
|
||||
form.get_context()
|
||||
|
||||
def test_get_context_valid_site_installed(self):
|
||||
request = MagicMock()
|
||||
form = ContactForm(request=request, data=TEST_DATA)
|
||||
context = form.get_context()
|
||||
self.assertIn("site", context)
|
||||
self.assertIn("name", context)
|
||||
self.assertIn("email", context)
|
||||
self.assertIn("body", context)
|
||||
self.assertIn('site', context)
|
||||
self.assertIn('name', context)
|
||||
self.assertIn('email', context)
|
||||
self.assertIn('body', context)
|
||||
|
||||
def test_get_context_valid_site_not_installed(self):
|
||||
request = MagicMock()
|
||||
form = ContactForm(request=request, data=TEST_DATA)
|
||||
with patch("contact_form.forms.Site") as sitemock:
|
||||
with mock.patch('contact_form.forms.Site') as sitemock:
|
||||
sitemock._meta.installed = False
|
||||
context = form.get_context()
|
||||
self.assertIn("site", context)
|
||||
self.assertIn("name", context)
|
||||
self.assertIn("email", context)
|
||||
self.assertIn("body", context)
|
||||
self.assertIn('site', context)
|
||||
self.assertIn('name', context)
|
||||
self.assertIn('email', context)
|
||||
self.assertIn('body', context)
|
||||
|
||||
def test_message(self):
|
||||
request = Mock()
|
||||
request.META = {"REMOTE_ADDR": "127.0.0.1"}
|
||||
request.META = {'REMOTE_ADDR': '127.0.0.1'}
|
||||
form = ContactForm(request=request, data=TEST_DATA)
|
||||
message = form.message()
|
||||
self.assertIn(TEST_DATA["name"], message)
|
||||
self.assertIn(TEST_DATA["email"], message)
|
||||
self.assertIn(TEST_DATA["body"], message)
|
||||
self.assertIn("127.0.0.1", message)
|
||||
self.assertIn(TEST_DATA['name'], message)
|
||||
self.assertIn(TEST_DATA['email'], message)
|
||||
self.assertIn(TEST_DATA['body'], message)
|
||||
self.assertIn('127.0.0.1', message)
|
||||
|
||||
def test_subject(self):
|
||||
request = Mock()
|
||||
form = ContactForm(request=request, data=TEST_DATA)
|
||||
subject = form.subject()
|
||||
self.assertIn(Site.objects.get_current().name, subject)
|
||||
self.assertIn(TEST_DATA["name"], subject)
|
||||
self.assertIn(TEST_DATA['name'], subject)
|
||||
|
|
|
@ -2,122 +2,126 @@
|
|||
Tests for :py:mod:`contact_form.views`.
|
||||
|
||||
"""
|
||||
from django.contrib.auth import get_user_model
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from django.core import mail
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_EMAIL = "test@example.org"
|
||||
TEST_NAME = "Example Tester".split()
|
||||
TEST_MESSAGE = """
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
TEST_EMAIL = 'test@example.org'
|
||||
TEST_NAME = 'Example Tester'.split()
|
||||
TEST_MESSAGE = '''
|
||||
This is a really unimportant test message.
|
||||
"""
|
||||
'''
|
||||
|
||||
|
||||
class ContactFormViewTest(TestCase):
|
||||
|
||||
def _setup_user(self, **kwargs):
|
||||
return User.objects.create_user(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD, **kwargs
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD,
|
||||
**kwargs)
|
||||
|
||||
def test_get_contact_form_template(self):
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
self.assertTemplateUsed(response, "contact_form/contact_form.html")
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
self.assertTemplateUsed(response, 'contact_form/contact_form.html')
|
||||
|
||||
def test_get_contact_form_anonymous_status(self):
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_contact_form_anonymous_has_empty_form(self):
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
self.assertIn("form", response.context)
|
||||
form = response.context["form"]
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
self.assertIn('form', response.context)
|
||||
form = response.context['form']
|
||||
self.assertEqual(len(form.initial), 0)
|
||||
|
||||
def test_get_contact_form_fields_anonymous(self):
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
for name in ("name", "email", "body"):
|
||||
self.assertIn(name, response.context["form"].fields)
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
for name in ('name', 'email', 'body'):
|
||||
self.assertIn(name, response.context['form'].fields)
|
||||
|
||||
def test_post_empty_form_template(self):
|
||||
response = self.client.post(reverse("contact_form"), {})
|
||||
self.assertTemplateUsed(response, "contact_form/contact_form.html")
|
||||
response = self.client.post(reverse('contact_form'), {})
|
||||
self.assertTemplateUsed(response, 'contact_form/contact_form.html')
|
||||
|
||||
def test_post_empty_form_status(self):
|
||||
response = self.client.post(reverse("contact_form"), {})
|
||||
response = self.client.post(reverse('contact_form'), {})
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_post_empty_form_validation_errors(self):
|
||||
response = self.client.post(reverse("contact_form"), {})
|
||||
self.assertIn("form", response.context)
|
||||
form = response.context["form"]
|
||||
response = self.client.post(reverse('contact_form'), {})
|
||||
self.assertIn('form', response.context)
|
||||
form = response.context['form']
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertEqual(len(form.errors), 3)
|
||||
|
||||
def test_post_empty_form_no_mail(self):
|
||||
self.client.post(reverse("contact_form"), {})
|
||||
self.client.post(reverse('contact_form'), {})
|
||||
self.assertEqual(len(mail.outbox), 0)
|
||||
|
||||
def test_get_contact_form_logged_in_no_fullname_initial(self):
|
||||
self._setup_user()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
self.assertIn("form", response.context)
|
||||
form = response.context["form"]
|
||||
self.assertEqual(form.initial, {"name": TEST_USER, "email": TEST_EMAIL})
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
self.assertIn('form', response.context)
|
||||
form = response.context['form']
|
||||
self.assertEqual(
|
||||
form.initial, {'name': TEST_USER, 'email': TEST_EMAIL})
|
||||
|
||||
def test_get_contact_form_logged_in_fullname_initial(self):
|
||||
self._setup_user(first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self._setup_user(
|
||||
first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
self.assertIn("form", response.context)
|
||||
form = response.context["form"]
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
self.assertIn('form', response.context)
|
||||
form = response.context['form']
|
||||
self.assertEqual(
|
||||
form.initial, {"name": " ".join(TEST_NAME), "email": TEST_EMAIL}
|
||||
)
|
||||
form.initial,
|
||||
{'name': " ".join(TEST_NAME), 'email': TEST_EMAIL})
|
||||
|
||||
def test_post_filled_form_anonymous_redirects(self):
|
||||
response = self.client.post(
|
||||
reverse("contact_form"),
|
||||
{"name": TEST_USER, "email": TEST_EMAIL, "body": TEST_MESSAGE},
|
||||
)
|
||||
self.assertRedirects(response, reverse("contact_success"))
|
||||
response = self.client.post(reverse('contact_form'), {
|
||||
'name': TEST_USER, 'email': TEST_EMAIL, 'body': TEST_MESSAGE})
|
||||
self.assertRedirects(response, reverse('contact_success'))
|
||||
|
||||
def test_post_filled_form_anonymous_mail(self):
|
||||
self.client.post(
|
||||
reverse("contact_form"),
|
||||
{"name": TEST_USER, "email": TEST_EMAIL, "body": TEST_MESSAGE},
|
||||
)
|
||||
self.client.post(reverse('contact_form'), {
|
||||
'name': TEST_USER, 'email': TEST_EMAIL, 'body': TEST_MESSAGE})
|
||||
self.assertEqual(len(mail.outbox), 1)
|
||||
|
||||
def test_post_filled_form_logged_in_redirects(self):
|
||||
self._setup_user(first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self._setup_user(
|
||||
first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
reverse("contact_form"),
|
||||
{"name": " ".join(TEST_NAME), "email": TEST_EMAIL, "body": TEST_MESSAGE},
|
||||
)
|
||||
self.assertRedirects(response, reverse("contact_success"))
|
||||
response = self.client.post(reverse('contact_form'), {
|
||||
'name': " ".join(TEST_NAME), 'email': TEST_EMAIL,
|
||||
'body': TEST_MESSAGE})
|
||||
self.assertRedirects(response, reverse('contact_success'))
|
||||
|
||||
def test_post_filled_form_logged_in_mail(self):
|
||||
self._setup_user(first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self._setup_user(
|
||||
first_name=TEST_NAME[0], last_name=TEST_NAME[1])
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.client.post(
|
||||
reverse("contact_form"),
|
||||
{"name": " ".join(TEST_NAME), "email": TEST_EMAIL, "body": TEST_MESSAGE},
|
||||
)
|
||||
self.client.post(reverse('contact_form'), {
|
||||
'name': " ".join(TEST_NAME), 'email': TEST_EMAIL,
|
||||
'body': TEST_MESSAGE})
|
||||
self.assertEqual(len(mail.outbox), 1)
|
||||
|
||||
|
||||
class ContactSuccessViewTest(TestCase):
|
||||
|
||||
def test_get_template(self):
|
||||
response = self.client.get(reverse("contact_success"))
|
||||
self.assertTemplateUsed(response, "contact_form/contact_success.html")
|
||||
response = self.client.get(reverse('contact_success'))
|
||||
self.assertTemplateUsed(response, 'contact_form/contact_success.html')
|
||||
|
||||
def test_get_status(self):
|
||||
response = self.client.get(reverse("contact_success"))
|
||||
response = self.client.get(reverse('contact_success'))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
|
|
@ -3,65 +3,66 @@ Tests for :py:mod:`dashboard.views`.
|
|||
|
||||
"""
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
|
||||
|
||||
class IndexViewTest(TestCase):
|
||||
|
||||
def test_index_view(self):
|
||||
response = self.client.get(reverse("dashboard"))
|
||||
response = self.client.get(reverse('dashboard'))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertTemplateUsed(response, "dashboard/index.html")
|
||||
self.assertTemplateUsed(response, 'dashboard/index.html')
|
||||
|
||||
|
||||
class UserDashboardViewTest(TestCase):
|
||||
|
||||
def _create_test_user(self):
|
||||
self.user = User.objects.create(username=TEST_USER)
|
||||
self.user.set_password(TEST_PASSWORD)
|
||||
self.user.save()
|
||||
|
||||
def test_user_dashboard_view_no_user(self):
|
||||
response = self.client.get(
|
||||
reverse("customer_dashboard", kwargs={"slug": TEST_USER})
|
||||
)
|
||||
response = self.client.get(reverse(
|
||||
'customer_dashboard', kwargs={'slug': TEST_USER}))
|
||||
self.assertEqual(response.status_code, 404)
|
||||
|
||||
def test_user_dashboard_view_anonymous(self):
|
||||
User.objects.create(username=TEST_USER)
|
||||
response = self.client.get(
|
||||
reverse("customer_dashboard", kwargs={"slug": TEST_USER})
|
||||
)
|
||||
response = self.client.get(reverse(
|
||||
'customer_dashboard', kwargs={'slug': TEST_USER}))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_user_dashboard_view_logged_in_ok(self):
|
||||
self._create_test_user()
|
||||
self.assertTrue(self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(
|
||||
reverse("customer_dashboard", kwargs={"slug": TEST_USER})
|
||||
)
|
||||
self.assertTrue(
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(reverse(
|
||||
'customer_dashboard', kwargs={'slug': TEST_USER}))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_user_dashboard_view_logged_in_template(self):
|
||||
self._create_test_user()
|
||||
self.assertTrue(self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(
|
||||
reverse("customer_dashboard", kwargs={"slug": TEST_USER})
|
||||
)
|
||||
self.assertTemplateUsed(response, "dashboard/user_dashboard.html")
|
||||
self.assertTrue(
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(reverse(
|
||||
'customer_dashboard', kwargs={'slug': TEST_USER}))
|
||||
self.assertTemplateUsed(response, 'dashboard/user_dashboard.html')
|
||||
|
||||
def test_user_dashboard_view_logged_in_context_fresh(self):
|
||||
self._create_test_user()
|
||||
self.assertTrue(self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(
|
||||
reverse("customer_dashboard", kwargs={"slug": TEST_USER})
|
||||
)
|
||||
self.assertIn("dashboard_user", response.context)
|
||||
self.assertEqual(self.user, response.context["dashboard_user"])
|
||||
self.assertIn("hosting_packages", response.context)
|
||||
self.assertEqual(len(response.context["hosting_packages"]), 0)
|
||||
self.assertTrue(
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD))
|
||||
response = self.client.get(reverse(
|
||||
'customer_dashboard', kwargs={'slug': TEST_USER}))
|
||||
self.assertIn('dashboard_user', response.context)
|
||||
self.assertEqual(self.user, response.context['dashboard_user'])
|
||||
self.assertIn('hosting_packages', response.context)
|
||||
self.assertEqual(len(response.context['hosting_packages']), 0)
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
from django.core.urlresolvers import reverse
|
||||
|
||||
|
||||
class TestMailDomainAdmin(TestCase):
|
||||
def test_admin_for_maildomain(self):
|
||||
admin_url = reverse("admin:domains_maildomain_changelist")
|
||||
admin_url = reverse('admin:domains_maildomain_changelist')
|
||||
self.assertIsNotNone(admin_url)
|
||||
|
|
|
@ -2,42 +2,51 @@
|
|||
Tests for :py:mod:`domains.forms`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.forms import ValidationError
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
from django.utils.translation import ugettext as _
|
||||
|
||||
from domains.forms import relative_domain_validator, CreateHostingDomainForm
|
||||
|
||||
|
||||
class RelativeDomainValidatorTest(TestCase):
|
||||
|
||||
def test_valid_domainname(self):
|
||||
relative_domain_validator("example.org")
|
||||
relative_domain_validator('example.org')
|
||||
|
||||
def test_domain_name_too_long(self):
|
||||
with self.assertRaisesMessage(ValidationError, _("host name too long")):
|
||||
relative_domain_validator("e" * 255)
|
||||
with self.assertRaisesMessage(
|
||||
ValidationError, _('host name too long')):
|
||||
relative_domain_validator('e' * 255)
|
||||
|
||||
def test_domain_name_part_too_long(self):
|
||||
with self.assertRaisesMessage(ValidationError, _("invalid domain name")):
|
||||
relative_domain_validator("a" * 64 + ".org")
|
||||
with self.assertRaisesMessage(
|
||||
ValidationError, _('invalid domain name')):
|
||||
relative_domain_validator('a' * 64 + '.org')
|
||||
|
||||
def test_domain_name_illegal_characters(self):
|
||||
with self.assertRaisesMessage(ValidationError, _("invalid domain name")):
|
||||
relative_domain_validator("eXampl3.org")
|
||||
with self.assertRaisesMessage(
|
||||
ValidationError, _('invalid domain name')):
|
||||
relative_domain_validator('eXampl3.org')
|
||||
|
||||
def test_domain_name_starts_with_dash(self):
|
||||
with self.assertRaisesMessage(ValidationError, _("invalid domain name")):
|
||||
relative_domain_validator("-example.org")
|
||||
with self.assertRaisesMessage(
|
||||
ValidationError, _('invalid domain name')):
|
||||
relative_domain_validator('-example.org')
|
||||
|
||||
def test_domain_name_ends_with_dash(self):
|
||||
with self.assertRaisesMessage(ValidationError, _("invalid domain name")):
|
||||
relative_domain_validator("example-.org")
|
||||
with self.assertRaisesMessage(
|
||||
ValidationError, _('invalid domain name')):
|
||||
relative_domain_validator('example-.org')
|
||||
|
||||
|
||||
class CreateHostingDomainFormTest(TestCase):
|
||||
|
||||
def test_constructor_needs_hostingpackage(self):
|
||||
instance = MagicMock()
|
||||
with self.assertRaises(KeyError):
|
||||
|
@ -47,53 +56,50 @@ class CreateHostingDomainFormTest(TestCase):
|
|||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateHostingDomainForm(instance, hostingpackage=hostingpackage)
|
||||
self.assertTrue(hasattr(form, "hosting_package"))
|
||||
self.assertTrue(hasattr(form, 'hosting_package'))
|
||||
self.assertEqual(form.hosting_package, hostingpackage)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("create_hosting_domain", kwargs={"package": 42}),
|
||||
)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'create_hosting_domain', kwargs={'package': 42}))
|
||||
self.assertEqual(len(form.helper.layout.fields), 2)
|
||||
self.assertEqual(form.helper.layout.fields[1].name, "submit")
|
||||
self.assertEqual(form.helper.layout.fields[1].name, 'submit')
|
||||
|
||||
def test_domain_field_has_relative_domain_validator(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateHostingDomainForm(instance, hostingpackage=hostingpackage)
|
||||
self.assertIn(relative_domain_validator, form.fields["domain"].validators)
|
||||
self.assertIn(
|
||||
relative_domain_validator, form.fields['domain'].validators)
|
||||
|
||||
def test_clean(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateHostingDomainForm(
|
||||
instance, hostingpackage=hostingpackage, data={"domain": "example.org"}
|
||||
)
|
||||
instance, hostingpackage=hostingpackage,
|
||||
data={'domain': 'example.org'})
|
||||
self.assertTrue(form.is_valid())
|
||||
self.assertIn("hosting_package", form.cleaned_data)
|
||||
self.assertEqual(hostingpackage, form.cleaned_data["hosting_package"])
|
||||
self.assertIn('hosting_package', form.cleaned_data)
|
||||
self.assertEqual(hostingpackage, form.cleaned_data['hosting_package'])
|
||||
|
||||
def test_save(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateHostingDomainForm(
|
||||
instance, hostingpackage=hostingpackage, data={"domain": "example.org"}
|
||||
)
|
||||
instance, hostingpackage=hostingpackage,
|
||||
data={'domain': 'example.org'})
|
||||
self.assertTrue(form.is_valid())
|
||||
with patch("domains.forms.HostingDomain") as domain:
|
||||
with patch('domains.forms.HostingDomain') as domain:
|
||||
form.save()
|
||||
domain.objects.create_for_hosting_package.assert_called_with(
|
||||
commit=True, **form.cleaned_data
|
||||
)
|
||||
commit=True, **form.cleaned_data)
|
||||
form.save(commit=False)
|
||||
domain.objects.create_for_hosting_package.assert_called_with(
|
||||
commit=False, **form.cleaned_data
|
||||
)
|
||||
commit=False, **form.cleaned_data)
|
||||
|
||||
def test_save_m2m(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateHostingDomainForm(
|
||||
instance, hostingpackage=hostingpackage, data={"domain": "example.org"}
|
||||
)
|
||||
instance, hostingpackage=hostingpackage,
|
||||
data={'domain': 'example.org'})
|
||||
form.save_m2m()
|
||||
|
|
|
@ -2,7 +2,9 @@
|
|||
Tests for :py:mod:`domains.models`.
|
||||
|
||||
"""
|
||||
from unittest.mock import patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from mock import patch
|
||||
|
||||
from django.test import TestCase
|
||||
from django.contrib.auth import get_user_model
|
||||
|
@ -18,38 +20,41 @@ from domains.models import (
|
|||
HostingDomain,
|
||||
MailDomain,
|
||||
)
|
||||
from hostingpackages.models import CustomerHostingPackage, HostingPackageTemplate
|
||||
from hostingpackages.models import (
|
||||
CustomerHostingPackage,
|
||||
HostingPackageTemplate,
|
||||
)
|
||||
|
||||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_USER = 'test'
|
||||
|
||||
|
||||
class MailDomainTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
self.assertEqual(str(md), "example.org")
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
self.assertEqual(str(md), 'example.org')
|
||||
|
||||
def test_get_mailaddresses(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
from managemails.models import MailAddress
|
||||
|
||||
addrmock = MailAddress.objects.create(localpart="info", domain=md)
|
||||
addrmock = MailAddress.objects.create(localpart='info', domain=md)
|
||||
self.assertIn(addrmock, md.get_mailaddresses())
|
||||
self.assertIn(addrmock, md.mailaddresses)
|
||||
|
||||
|
||||
class HostingDomainManagerTest(TestCase):
|
||||
|
||||
def _setup_hosting_package(self):
|
||||
template = HostingPackageTemplate.objects.create(
|
||||
name="testpackagetemplate", mailboxcount=0, diskspace=1, diskspace_unit=0
|
||||
)
|
||||
name='testpackagetemplate', mailboxcount=0, diskspace=1,
|
||||
diskspace_unit=0)
|
||||
customer = User.objects.create_user(username=TEST_USER)
|
||||
package = CustomerHostingPackage.objects.create_from_template(
|
||||
customer, template, "testpackage"
|
||||
)
|
||||
with patch("hostingpackages.models.settings") as hmsettings:
|
||||
customer, template, 'testpackage')
|
||||
with patch('hostingpackages.models.settings') as hmsettings:
|
||||
hmsettings.OSUSER_DEFAULT_GROUPS = []
|
||||
package.save()
|
||||
return package
|
||||
|
@ -57,8 +62,7 @@ class HostingDomainManagerTest(TestCase):
|
|||
def test_create_for_hosting_package_with_commit(self):
|
||||
package = self._setup_hosting_package()
|
||||
hostingdomain = HostingDomain.objects.create_for_hosting_package(
|
||||
package, "example.org", True
|
||||
)
|
||||
package, 'example.org', True)
|
||||
|
||||
self.assertIsNotNone(hostingdomain)
|
||||
self.assertTrue(hostingdomain.customer, package.customer)
|
||||
|
@ -66,60 +70,70 @@ class HostingDomainManagerTest(TestCase):
|
|||
def test_create_for_hosting_package_no_commit(self):
|
||||
package = self._setup_hosting_package()
|
||||
hostingdomain = HostingDomain.objects.create_for_hosting_package(
|
||||
package, "example.org", False
|
||||
)
|
||||
package, 'example.org', False)
|
||||
|
||||
self.assertIsNotNone(hostingdomain)
|
||||
self.assertTrue(hostingdomain.customer, package.customer)
|
||||
|
||||
|
||||
class HostingDomainTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
hostingdomain = HostingDomain(domain="test")
|
||||
self.assertEqual(str(hostingdomain), "test")
|
||||
hostingdomain = HostingDomain(domain='test')
|
||||
self.assertEqual(str(hostingdomain), 'test')
|
||||
|
||||
|
||||
class DNSDomainTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnsdomain = DNSDomain(domain="test")
|
||||
self.assertEqual(str(dnsdomain), "test")
|
||||
dnsdomain = DNSDomain(domain='test')
|
||||
self.assertEqual(str(dnsdomain), 'test')
|
||||
|
||||
|
||||
class DNSRecordTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnsrecord = DNSRecord(name="localhost", recordtype="A", content="127.0.0.1")
|
||||
self.assertEqual(str(dnsrecord), "localhost IN A 127.0.0.1")
|
||||
dnsrecord = DNSRecord(
|
||||
name='localhost', recordtype='A', content='127.0.0.1')
|
||||
self.assertEqual(str(dnsrecord), 'localhost IN A 127.0.0.1')
|
||||
|
||||
|
||||
class DNSSupermasterTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnssupermaster = DNSSupermaster(ip="127.0.0.1", nameserver="dns.example.org")
|
||||
self.assertEqual(str(dnssupermaster), "127.0.0.1 dns.example.org")
|
||||
dnssupermaster = DNSSupermaster(
|
||||
ip='127.0.0.1', nameserver='dns.example.org')
|
||||
self.assertEqual(str(dnssupermaster), '127.0.0.1 dns.example.org')
|
||||
|
||||
|
||||
class DNSCommentTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnscomment = DNSComment(name="localhost", commenttype="A", comment="good stuff")
|
||||
self.assertEqual(str(dnscomment), "localhost IN A: good stuff")
|
||||
dnscomment = DNSComment(
|
||||
name='localhost', commenttype='A', comment='good stuff')
|
||||
self.assertEqual(str(dnscomment), 'localhost IN A: good stuff')
|
||||
|
||||
|
||||
class DNSDomainMetadataTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnsdomain = DNSDomain(domain="test")
|
||||
dnsdomain = DNSDomain(domain='test')
|
||||
dnsdomainmetadata = DNSDomainMetadata(
|
||||
domain=dnsdomain, kind="SOA-EDIT", content="INCEPTION"
|
||||
)
|
||||
self.assertEqual(str(dnsdomainmetadata), "test SOA-EDIT INCEPTION")
|
||||
domain=dnsdomain, kind='SOA-EDIT', content='INCEPTION')
|
||||
self.assertEqual(str(dnsdomainmetadata), 'test SOA-EDIT INCEPTION')
|
||||
|
||||
|
||||
class DNSCryptoKeyTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnsdomain = DNSDomain(domain="test")
|
||||
dnscryptokey = DNSCryptoKey(domain=dnsdomain, content="testvalue")
|
||||
self.assertEqual(str(dnscryptokey), "test testvalue")
|
||||
dnsdomain = DNSDomain(domain='test')
|
||||
dnscryptokey = DNSCryptoKey(domain=dnsdomain, content='testvalue')
|
||||
self.assertEqual(str(dnscryptokey), 'test testvalue')
|
||||
|
||||
|
||||
class DNSTSIGKeyTest(TestCase):
|
||||
|
||||
def test___str__(self):
|
||||
dnstsigkey = DNSTSIGKey(name="testkey", algorithm="hmac-md5", secret="dummykey")
|
||||
self.assertEqual(str(dnstsigkey), "testkey hmac-md5 XXXX")
|
||||
dnstsigkey = DNSTSIGKey(
|
||||
name='testkey', algorithm='hmac-md5', secret='dummykey')
|
||||
self.assertEqual(str(dnstsigkey), 'testkey hmac-md5 XXXX')
|
||||
|
|
|
@ -2,152 +2,149 @@
|
|||
Tests for :py:mod:`domains.views`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from hostingpackages.models import (
|
||||
CustomerHostingPackage,
|
||||
HostingPackageTemplate,
|
||||
)
|
||||
|
||||
from domains.views import CreateHostingDomain
|
||||
from hostingpackages.models import CustomerHostingPackage, HostingPackageTemplate
|
||||
|
||||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_EMAIL = "test@example.org"
|
||||
TEST_NAME = "Example Tester".split()
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
TEST_EMAIL = 'test@example.org'
|
||||
TEST_NAME = 'Example Tester'.split()
|
||||
|
||||
|
||||
class CreateHostingDomainTest(TestCase):
|
||||
|
||||
def _setup_hosting_package(self, customer):
|
||||
template = HostingPackageTemplate.objects.create(
|
||||
name="testpackagetemplate", mailboxcount=0, diskspace=1, diskspace_unit=0
|
||||
)
|
||||
name='testpackagetemplate', mailboxcount=0, diskspace=1,
|
||||
diskspace_unit=0)
|
||||
package = CustomerHostingPackage.objects.create_from_template(
|
||||
customer, template, "testpackage"
|
||||
)
|
||||
with patch("hostingpackages.models.settings") as hmsettings:
|
||||
customer, template, 'testpackage')
|
||||
with patch('hostingpackages.models.settings') as hmsettings:
|
||||
hmsettings.OSUSER_DEFAULT_GROUPS = []
|
||||
package.save()
|
||||
return package
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": 1})
|
||||
)
|
||||
reverse('create_hosting_domain', kwargs={'package': 1}))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_regular_user(self):
|
||||
customer = User.objects.create_user(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
package = self._setup_hosting_package(customer)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id})
|
||||
)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id})
|
||||
)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id})
|
||||
)
|
||||
self.assertTemplateUsed(response, "domains/hostingdomain_create.html")
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}))
|
||||
self.assertTemplateUsed(response, 'domains/hostingdomain_create.html')
|
||||
|
||||
def test_get_no_package_found(self):
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": 1})
|
||||
)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': 1}))
|
||||
self.assertEqual(response.status_code, 404)
|
||||
|
||||
def test_get_get_form_kwargs(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = CreateHostingDomain(
|
||||
request=MagicMock(), kwargs={"package": str(package.id)}
|
||||
)
|
||||
request=MagicMock(), kwargs={'package': str(package.id)})
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], package)
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], package)
|
||||
|
||||
def test_get_context_data_has_hosting_package(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id})
|
||||
)
|
||||
self.assertIn("hostingpackage", response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], package)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}))
|
||||
self.assertIn('hostingpackage', response.context)
|
||||
self.assertEqual(response.context['hostingpackage'], package)
|
||||
|
||||
def test_get_context_data_has_customer(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id})
|
||||
)
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], customer)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}))
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id}),
|
||||
data={"domain": "example.org"},
|
||||
)
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}),
|
||||
data={'domain': 'example.org'})
|
||||
self.assertRedirects(response, package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
customer = User.objects.create_user("customer")
|
||||
customer = User.objects.create_user('customer')
|
||||
package = self._setup_hosting_package(customer)
|
||||
User.objects.create_superuser(
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD
|
||||
)
|
||||
TEST_USER, email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
reverse("create_hosting_domain", kwargs={"package": package.id}),
|
||||
follow=True,
|
||||
data={"domain": "example.org"},
|
||||
)
|
||||
messages = list(response.context["messages"])
|
||||
reverse('create_hosting_domain',
|
||||
kwargs={'package': package.id}), follow=True,
|
||||
data={'domain': 'example.org'})
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual("Successfully created domain example.org", str(messages[0]))
|
||||
self.assertEqual(
|
||||
'Successfully created domain example.org', str(messages[0]))
|
||||
|
|
|
@ -5,49 +5,54 @@ This module defines views related to domains.
|
|||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from braces.views import StaffuserRequiredMixin
|
||||
from django.contrib import messages
|
||||
from django.shortcuts import get_object_or_404, redirect
|
||||
from django.utils.translation import ugettext as _
|
||||
from django.contrib.auth.mixins import LoginRequiredMixin
|
||||
from django.shortcuts import redirect, get_object_or_404
|
||||
from django.views.generic.edit import CreateView
|
||||
from django.utils.translation import ugettext as _
|
||||
from django.contrib import messages
|
||||
|
||||
from hostingpackages.models import CustomerHostingPackage
|
||||
|
||||
from .forms import CreateHostingDomainForm
|
||||
from .models import HostingDomain
|
||||
|
||||
|
||||
class CreateHostingDomain(StaffuserRequiredMixin, CreateView):
|
||||
class CreateHostingDomain(
|
||||
LoginRequiredMixin, StaffuserRequiredMixin, CreateView
|
||||
):
|
||||
"""
|
||||
This view is used for creating a new HostingDomain instance for an existing
|
||||
hosting package.
|
||||
"""
|
||||
|
||||
"""
|
||||
model = HostingDomain
|
||||
raise_exception = True
|
||||
template_name_suffix = "_create"
|
||||
template_name_suffix = '_create'
|
||||
form_class = CreateHostingDomainForm
|
||||
|
||||
def _get_hosting_package(self):
|
||||
return get_object_or_404(CustomerHostingPackage, pk=int(self.kwargs["package"]))
|
||||
return get_object_or_404(
|
||||
CustomerHostingPackage, pk=int(self.kwargs['package']))
|
||||
|
||||
def get_form_kwargs(self):
|
||||
kwargs = super(CreateHostingDomain, self).get_form_kwargs()
|
||||
kwargs["hostingpackage"] = self._get_hosting_package()
|
||||
kwargs['hostingpackage'] = self._get_hosting_package()
|
||||
return kwargs
|
||||
|
||||
def get_context_data(self, **kwargs):
|
||||
context = super(CreateHostingDomain, self).get_context_data(**kwargs)
|
||||
hosting_package = self._get_hosting_package()
|
||||
context.update(
|
||||
{"hostingpackage": hosting_package, "customer": hosting_package.customer}
|
||||
)
|
||||
context.update({
|
||||
'hostingpackage': hosting_package,
|
||||
'customer': hosting_package.customer,
|
||||
})
|
||||
return context
|
||||
|
||||
def form_valid(self, form):
|
||||
hostingdomain = form.save()
|
||||
messages.success(
|
||||
self.request,
|
||||
_("Successfully created domain {domainname}").format(
|
||||
domainname=hostingdomain.domain
|
||||
),
|
||||
_('Successfully created domain {domainname}').format(
|
||||
domainname=hostingdomain.domain)
|
||||
)
|
||||
return redirect(self._get_hosting_package())
|
||||
|
|
|
@ -38,10 +38,8 @@ DEBUG = False
|
|||
# ######### MANAGER CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#admins
|
||||
ADMINS = (
|
||||
(
|
||||
get_env_variable("GVA_ADMIN_NAME", default="Admin"),
|
||||
get_env_variable("GVA_ADMIN_EMAIL", default="admin@example.org"),
|
||||
),
|
||||
(get_env_variable('GVA_ADMIN_NAME', default='Admin'),
|
||||
get_env_variable('GVA_ADMIN_EMAIL', default='admin@example.org')),
|
||||
)
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#managers
|
||||
|
@ -52,13 +50,13 @@ MANAGERS = ADMINS
|
|||
# ######### DATABASE CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#databases
|
||||
DATABASES = {
|
||||
"default": {
|
||||
"ENGINE": "django.db.backends.postgresql",
|
||||
"NAME": get_env_variable("GVA_PGSQL_DATABASE", default="gnuviechadmin"),
|
||||
"USER": get_env_variable("GVA_PGSQL_USER", default="gnuviechadmin"),
|
||||
"PASSWORD": get_env_variable("GVA_PGSQL_PASSWORD"),
|
||||
"HOST": get_env_variable("GVA_PGSQL_HOSTNAME", default="db"),
|
||||
"PORT": get_env_variable("GVA_PGSQL_PORT", int, default=5432),
|
||||
'default': {
|
||||
'ENGINE': 'django.db.backends.postgresql',
|
||||
'NAME': get_env_variable('GVA_PGSQL_DATABASE', default='gnuviechadmin'),
|
||||
'USER': get_env_variable('GVA_PGSQL_USER', default='gnuviechadmin'),
|
||||
'PASSWORD': get_env_variable('GVA_PGSQL_PASSWORD'),
|
||||
'HOST': get_env_variable('GVA_PGSQL_HOSTNAME', default='db'),
|
||||
'PORT': get_env_variable('GVA_PGSQL_PORT', int, default=5432),
|
||||
}
|
||||
}
|
||||
# ######### END DATABASE CONFIGURATION
|
||||
|
@ -66,15 +64,15 @@ DATABASES = {
|
|||
|
||||
# ######### GENERAL CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#time-zone
|
||||
TIME_ZONE = "Europe/Berlin"
|
||||
TIME_ZONE = 'Europe/Berlin'
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#language-code
|
||||
LANGUAGE_CODE = "en-us"
|
||||
LANGUAGE_CODE = 'en-us'
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#site-id
|
||||
SITE_ID = 1
|
||||
SITES_DOMAIN_NAME = get_env_variable("GVA_DOMAIN_NAME")
|
||||
SITES_SITE_NAME = get_env_variable("GVA_SITE_NAME")
|
||||
SITES_DOMAIN_NAME = get_env_variable('GVA_DOMAIN_NAME')
|
||||
SITES_SITE_NAME = get_env_variable('GVA_SITE_NAME')
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#use-i18n
|
||||
USE_I18N = True
|
||||
|
@ -87,28 +85,33 @@ USE_TZ = True
|
|||
# ######### END GENERAL CONFIGURATION
|
||||
|
||||
|
||||
LOCALE_PATHS = (normpath(join(SITE_ROOT, "gnuviechadmin", "locale")),)
|
||||
LOCALE_PATHS = (
|
||||
normpath(join(SITE_ROOT, 'gnuviechadmin', 'locale')),
|
||||
)
|
||||
|
||||
|
||||
# ######### MEDIA CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#media-root
|
||||
MEDIA_ROOT = normpath(join(SITE_ROOT, "media"))
|
||||
MEDIA_ROOT = normpath(join(SITE_ROOT, 'media'))
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#media-url
|
||||
MEDIA_URL = "/media/"
|
||||
MEDIA_URL = '/media/'
|
||||
# ######### END MEDIA CONFIGURATION
|
||||
|
||||
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#static-url
|
||||
STATIC_URL = "/static/"
|
||||
STATIC_URL = '/static/'
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/contrib/staticfiles/#std:setting-STATICFILES_DIRS # noqa
|
||||
STATICFILES_DIRS = (normpath(join(SITE_ROOT, "gnuviechadmin", "assets")),)
|
||||
STATICFILES_DIRS = (
|
||||
normpath(join(SITE_ROOT, 'gnuviechadmin', 'assets')),
|
||||
)
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/contrib/staticfiles/#staticfiles-finders # noqa
|
||||
STATICFILES_FINDERS = (
|
||||
"django.contrib.staticfiles.finders.FileSystemFinder",
|
||||
"django.contrib.staticfiles.finders.AppDirectoriesFinder",
|
||||
'django.contrib.staticfiles.finders.FileSystemFinder',
|
||||
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
|
||||
)
|
||||
# ######### END STATIC FILE CONFIGURATION
|
||||
|
||||
|
@ -116,7 +119,7 @@ STATICFILES_FINDERS = (
|
|||
# ######### SECRET CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#secret-key
|
||||
# Note: This key should only be used for development and testing.
|
||||
SECRET_KEY = get_env_variable("GVA_SITE_SECRET")
|
||||
SECRET_KEY = get_env_variable('GVA_SITE_SECRET')
|
||||
# ######### END SECRET CONFIGURATION
|
||||
|
||||
|
||||
|
@ -129,7 +132,9 @@ ALLOWED_HOSTS = []
|
|||
|
||||
# ######### FIXTURE CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-FIXTURE_DIRS # noqa
|
||||
FIXTURE_DIRS = (normpath(join(SITE_ROOT, "fixtures")),)
|
||||
FIXTURE_DIRS = (
|
||||
normpath(join(SITE_ROOT, 'fixtures')),
|
||||
)
|
||||
# ######### END FIXTURE CONFIGURATION
|
||||
|
||||
|
||||
|
@ -137,25 +142,27 @@ FIXTURE_DIRS = (normpath(join(SITE_ROOT, "fixtures")),)
|
|||
# See: https://docs.djangoproject.com/en/1.9/ref/settings/#std:setting-TEMPLATES # noqa
|
||||
TEMPLATES = [
|
||||
{
|
||||
"BACKEND": "django.template.backends.django.DjangoTemplates",
|
||||
"DIRS": [normpath(join(DJANGO_ROOT, "templates"))],
|
||||
"APP_DIRS": True,
|
||||
"OPTIONS": {
|
||||
"context_processors": [
|
||||
"django.contrib.auth.context_processors.auth",
|
||||
"django.template.context_processors.debug",
|
||||
"django.template.context_processors.i18n",
|
||||
"django.template.context_processors.media",
|
||||
"django.template.context_processors.static",
|
||||
"django.template.context_processors.tz",
|
||||
"django.contrib.messages.context_processors.messages",
|
||||
"django.template.context_processors.request",
|
||||
'BACKEND': 'django.template.backends.django.DjangoTemplates',
|
||||
'DIRS': [
|
||||
normpath(join(DJANGO_ROOT, 'templates')),
|
||||
],
|
||||
'APP_DIRS': True,
|
||||
'OPTIONS': {
|
||||
'context_processors': [
|
||||
'django.contrib.auth.context_processors.auth',
|
||||
'django.template.context_processors.debug',
|
||||
'django.template.context_processors.i18n',
|
||||
'django.template.context_processors.media',
|
||||
'django.template.context_processors.static',
|
||||
'django.template.context_processors.tz',
|
||||
'django.contrib.messages.context_processors.messages',
|
||||
'django.template.context_processors.request',
|
||||
# custom context processors
|
||||
"gnuviechadmin.context_processors.navigation",
|
||||
"gnuviechadmin.context_processors.version_info",
|
||||
]
|
||||
'gnuviechadmin.context_processors.navigation',
|
||||
'gnuviechadmin.context_processors.version_info',
|
||||
],
|
||||
},
|
||||
}
|
||||
},
|
||||
]
|
||||
# ######### END TEMPLATE CONFIGURATION
|
||||
|
||||
|
@ -164,14 +171,14 @@ TEMPLATES = [
|
|||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#middleware-classes
|
||||
MIDDLEWARE = [
|
||||
# Default Django middleware.
|
||||
"django.middleware.common.CommonMiddleware",
|
||||
"django.contrib.sessions.middleware.SessionMiddleware",
|
||||
"django.middleware.csrf.CsrfViewMiddleware",
|
||||
"django.contrib.auth.middleware.AuthenticationMiddleware",
|
||||
"django.middleware.locale.LocaleMiddleware",
|
||||
"django.contrib.messages.middleware.MessageMiddleware",
|
||||
'django.middleware.common.CommonMiddleware',
|
||||
'django.contrib.sessions.middleware.SessionMiddleware',
|
||||
'django.middleware.csrf.CsrfViewMiddleware',
|
||||
'django.contrib.auth.middleware.AuthenticationMiddleware',
|
||||
'django.middleware.locale.LocaleMiddleware',
|
||||
'django.contrib.messages.middleware.MessageMiddleware',
|
||||
# uncomment next line to enable translation to browser locale
|
||||
"django.middleware.clickjacking.XFrameOptionsMiddleware",
|
||||
'django.middleware.clickjacking.XFrameOptionsMiddleware',
|
||||
]
|
||||
# ######### END MIDDLEWARE CONFIGURATION
|
||||
|
||||
|
@ -179,6 +186,7 @@ MIDDLEWARE = [
|
|||
AUTHENTICATION_BACKENDS = (
|
||||
# Needed to login by username in Django admin, regardless of `allauth`
|
||||
"django.contrib.auth.backends.ModelBackend",
|
||||
|
||||
# `allauth` specific authentication methods, such as login by e-mail
|
||||
"allauth.account.auth_backends.AuthenticationBackend",
|
||||
)
|
||||
|
@ -186,83 +194,87 @@ AUTHENTICATION_BACKENDS = (
|
|||
|
||||
# ######### URL CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#root-urlconf
|
||||
ROOT_URLCONF = "%s.urls" % SITE_NAME
|
||||
ROOT_URLCONF = '%s.urls' % SITE_NAME
|
||||
# ######### END URL CONFIGURATION
|
||||
|
||||
|
||||
# ######### TEST RUNNER CONFIGURATION
|
||||
TEST_RUNNER = "django.test.runner.DiscoverRunner"
|
||||
TEST_RUNNER = 'django.test.runner.DiscoverRunner'
|
||||
# ######### END TEST RUNNER CONFIGURATION
|
||||
|
||||
|
||||
# ######### APP CONFIGURATION
|
||||
DJANGO_APPS = (
|
||||
# Default Django apps:
|
||||
"django.contrib.auth",
|
||||
"django.contrib.contenttypes",
|
||||
"django.contrib.sessions",
|
||||
"django.contrib.sites",
|
||||
"django.contrib.messages",
|
||||
"django.contrib.staticfiles",
|
||||
'django.contrib.auth',
|
||||
'django.contrib.contenttypes',
|
||||
'django.contrib.sessions',
|
||||
'django.contrib.sites',
|
||||
'django.contrib.messages',
|
||||
'django.contrib.staticfiles',
|
||||
|
||||
# Useful template tags:
|
||||
"django.contrib.humanize",
|
||||
'django.contrib.humanize',
|
||||
|
||||
# Admin panel and documentation:
|
||||
"django.contrib.admin",
|
||||
'django.contrib.admin',
|
||||
|
||||
# Flatpages for about page
|
||||
"django.contrib.flatpages",
|
||||
"crispy_forms",
|
||||
'django.contrib.flatpages',
|
||||
|
||||
'crispy_forms',
|
||||
)
|
||||
|
||||
ALLAUTH_APPS = (
|
||||
"allauth",
|
||||
"allauth.account",
|
||||
"allauth.socialaccount",
|
||||
"allauth.socialaccount.providers.google",
|
||||
"allauth.socialaccount.providers.linkedin_oauth2",
|
||||
"allauth.socialaccount.providers.twitter",
|
||||
'allauth',
|
||||
'allauth.account',
|
||||
'allauth.socialaccount',
|
||||
'allauth.socialaccount.providers.google',
|
||||
'allauth.socialaccount.providers.linkedin_oauth2',
|
||||
'allauth.socialaccount.providers.twitter',
|
||||
)
|
||||
|
||||
# Apps specific for this project go here.
|
||||
LOCAL_APPS = (
|
||||
"dashboard",
|
||||
"taskresults",
|
||||
"ldaptasks",
|
||||
"mysqltasks",
|
||||
"pgsqltasks",
|
||||
"fileservertasks",
|
||||
"webtasks",
|
||||
"domains",
|
||||
"osusers",
|
||||
"managemails",
|
||||
"userdbs",
|
||||
"hostingpackages",
|
||||
"websites",
|
||||
"contact_form",
|
||||
'dashboard',
|
||||
'taskresults',
|
||||
'ldaptasks',
|
||||
'mysqltasks',
|
||||
'pgsqltasks',
|
||||
'fileservertasks',
|
||||
'webtasks',
|
||||
'domains',
|
||||
'osusers',
|
||||
'managemails',
|
||||
'userdbs',
|
||||
'hostingpackages',
|
||||
'websites',
|
||||
'contact_form',
|
||||
)
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#installed-apps
|
||||
INSTALLED_APPS = DJANGO_APPS + ALLAUTH_APPS + LOCAL_APPS
|
||||
|
||||
MESSAGE_TAGS = {
|
||||
messages.DEBUG: "",
|
||||
messages.ERROR: "alert-danger",
|
||||
messages.INFO: "alert-info",
|
||||
messages.SUCCESS: "alert-success",
|
||||
messages.WARNING: "alert-warning",
|
||||
messages.DEBUG: '',
|
||||
messages.ERROR: 'alert-danger',
|
||||
messages.INFO: 'alert-info',
|
||||
messages.SUCCESS: 'alert-success',
|
||||
messages.WARNING: 'alert-warning',
|
||||
}
|
||||
# ######### END APP CONFIGURATION
|
||||
|
||||
|
||||
# ######### ALLAUTH CONFIGURATION
|
||||
ACCOUNT_EMAIL_REQUIRED = True
|
||||
ACCOUNT_EMAIL_VERIFICATION = "mandatory"
|
||||
LOGIN_REDIRECT_URL = "/"
|
||||
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
|
||||
LOGIN_REDIRECT_URL = '/'
|
||||
SOCIALACCOUNT_QUERY_EMAIL = True
|
||||
# ######### END ALLAUTH CONFIGURATION
|
||||
|
||||
|
||||
# ######### CRISPY FORMS CONFIGURATION
|
||||
CRISPY_TEMPLATE_PACK = "bootstrap3"
|
||||
CRISPY_TEMPLATE_PACK = 'bootstrap3'
|
||||
# ######### END CRISPY_FORMS CONFIGURATION
|
||||
|
||||
|
||||
|
@ -274,197 +286,170 @@ CRISPY_TEMPLATE_PACK = "bootstrap3"
|
|||
# See http://docs.djangoproject.com/en/dev/topics/logging for
|
||||
# more details on how to customize your logging configuration.
|
||||
LOGGING = {
|
||||
"version": 1,
|
||||
"disable_existing_loggers": False,
|
||||
"formatters": {
|
||||
"verbose": {
|
||||
"format": "%(levelname)s %(asctime)s %(name)s "
|
||||
"%(module)s:%(lineno)d %(process)d %(thread)d %(message)s"
|
||||
'version': 1,
|
||||
'disable_existing_loggers': False,
|
||||
'formatters': {
|
||||
'verbose': {
|
||||
'format': '%(levelname)s %(asctime)s %(name)s '
|
||||
'%(module)s:%(lineno)d %(process)d %(thread)d %(message)s',
|
||||
},
|
||||
'simple': {
|
||||
'format': '%(levelname)s %(name)s:%(lineno)d %(message)s',
|
||||
},
|
||||
"simple": {"format": "%(levelname)s %(name)s:%(lineno)d %(message)s"},
|
||||
},
|
||||
"filters": {"require_debug_false": {"()": "django.utils.log.RequireDebugFalse"}},
|
||||
"handlers": {
|
||||
"mail_admins": {
|
||||
"level": "ERROR",
|
||||
"filters": ["require_debug_false"],
|
||||
"class": "django.utils.log.AdminEmailHandler",
|
||||
'filters': {
|
||||
'require_debug_false': {
|
||||
'()': 'django.utils.log.RequireDebugFalse'
|
||||
}
|
||||
},
|
||||
"loggers": {
|
||||
"django.request": {
|
||||
"handlers": ["mail_admins"],
|
||||
"level": "ERROR",
|
||||
"propagate": True,
|
||||
'handlers': {
|
||||
'mail_admins': {
|
||||
'level': 'ERROR',
|
||||
'filters': ['require_debug_false'],
|
||||
'class': 'django.utils.log.AdminEmailHandler'
|
||||
}
|
||||
},
|
||||
'loggers': {
|
||||
'django.request': {
|
||||
'handlers': ['mail_admins'],
|
||||
'level': 'ERROR',
|
||||
'propagate': True,
|
||||
},
|
||||
}
|
||||
}
|
||||
# ######### END LOGGING CONFIGURATION
|
||||
|
||||
|
||||
# ######### WSGI CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#wsgi-application
|
||||
WSGI_APPLICATION = "%s.wsgi.application" % SITE_NAME
|
||||
WSGI_APPLICATION = '%s.wsgi.application' % SITE_NAME
|
||||
# ######### END WSGI CONFIGURATION
|
||||
|
||||
|
||||
# ######### CELERY CONFIGURATION
|
||||
BROKER_URL = get_env_variable(
|
||||
"GVA_BROKER_URL", default="amqp://gnuviechadmin:gnuviechadmin@mq/gnuviechadmin"
|
||||
)
|
||||
BROKER_TRANSPORT_OPTIONS = {
|
||||
"max_retries": 3,
|
||||
"interval_start": 0,
|
||||
"interval_step": 0.2,
|
||||
"interval_max": 0.2,
|
||||
}
|
||||
'GVA_BROKER_URL',
|
||||
default='amqp://gnuviechadmin:gnuviechadmin@mq/gnuviechadmin')
|
||||
CELERY_RESULT_BACKEND = get_env_variable(
|
||||
"GVA_RESULTS_REDIS_URL", default="redis://:gnuviechadmin@redis:6379/0"
|
||||
)
|
||||
'GVA_RESULTS_REDIS_URL',
|
||||
default='redis://:gnuviechadmin@redis:6379/0')
|
||||
CELERY_TASK_RESULT_EXPIRES = None
|
||||
CELERY_ROUTES = ("gvacommon.celeryrouters.GvaRouter",)
|
||||
CELERY_TIMEZONE = "Europe/Berlin"
|
||||
CELERY_ROUTES = (
|
||||
'gvacommon.celeryrouters.GvaRouter',
|
||||
)
|
||||
CELERY_TIMEZONE = 'Europe/Berlin'
|
||||
CELERY_ENABLE_UTC = True
|
||||
CELERY_ACCEPT_CONTENT = ["json"]
|
||||
CELERY_TASK_SERIALIZER = "json"
|
||||
CELERY_RESULT_SERIALIZER = "json"
|
||||
CELERY_ACCEPT_CONTENT = ['json']
|
||||
CELERY_TASK_SERIALIZER = 'json'
|
||||
CELERY_RESULT_SERIALIZER = 'json'
|
||||
# ######### END CELERY CONFIGURATION
|
||||
|
||||
|
||||
# ######### CUSTOM APP CONFIGURATION
|
||||
OSUSER_MINUID = get_env_variable("GVA_MIN_OS_UID", int, default=10000)
|
||||
OSUSER_MINGID = get_env_variable("GVA_MIN_OS_GID", int, default=10000)
|
||||
OSUSER_USERNAME_PREFIX = get_env_variable("GVA_OSUSER_PREFIX", default="usr")
|
||||
OSUSER_HOME_BASEPATH = get_env_variable("GVA_OSUSER_HOME_BASEPATH", default="/home")
|
||||
OSUSER_MINUID = get_env_variable('GVA_MIN_OS_UID', int, default=10000)
|
||||
OSUSER_MINGID = get_env_variable('GVA_MIN_OS_GID', int, default=10000)
|
||||
OSUSER_USERNAME_PREFIX = get_env_variable('GVA_OSUSER_PREFIX', default='usr')
|
||||
OSUSER_HOME_BASEPATH = get_env_variable(
|
||||
'GVA_OSUSER_HOME_BASEPATH', default='/home')
|
||||
OSUSER_DEFAULT_SHELL = get_env_variable(
|
||||
"GVA_OSUSER_DEFAULT_SHELL", default="/usr/bin/rssh"
|
||||
)
|
||||
OSUSER_SFTP_GROUP = "sftponly"
|
||||
OSUSER_SSH_GROUP = "sshusers"
|
||||
'GVA_OSUSER_DEFAULT_SHELL', default='/usr/bin/rssh')
|
||||
OSUSER_SFTP_GROUP = 'sftponly'
|
||||
OSUSER_SSH_GROUP = 'sshusers'
|
||||
OSUSER_DEFAULT_GROUPS = [OSUSER_SFTP_GROUP]
|
||||
OSUSER_UPLOAD_SERVER = get_env_variable("GVA_OSUSER_UPLOADSERVER", default="file")
|
||||
OSUSER_UPLOAD_SERVER = get_env_variable(
|
||||
'GVA_OSUSER_UPLOADSERVER', default='file')
|
||||
|
||||
GVA_LINK_WEBMAIL = get_env_variable(
|
||||
"GVA_WEBMAIL_URL", default="https://webmail.example.org/"
|
||||
)
|
||||
'GVA_WEBMAIL_URL', default='https://webmail.example.org/')
|
||||
GVA_LINK_PHPMYADMIN = get_env_variable(
|
||||
"GVA_PHPMYADMIN_URL", default="https://phpmyadmin.example.org/"
|
||||
)
|
||||
'GVA_PHPMYADMIN_URL', default='https://phpmyadmin.example.org/')
|
||||
GVA_LINK_PHPPGADMIN = get_env_variable(
|
||||
"GVA_PHPPGADMIN_URL", default="https://phppgadmin.example.org/"
|
||||
)
|
||||
'GVA_PHPPGADMIN_URL', default='https://phppgadmin.example.org/')
|
||||
# ######### END CUSTOM APP CONFIGURATION
|
||||
|
||||
GVA_ENVIRONMENT = get_env_variable("GVA_ENVIRONMENT", default="prod")
|
||||
GVA_ENVIRONMENT = get_env_variable('GVA_ENVIRONMENT', default='prod')
|
||||
|
||||
# ######### STATIC FILE CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#static-root
|
||||
STATIC_ROOT = "/srv/gnuviechadmin/static/"
|
||||
|
||||
STATIC_ROOT = '/srv/gnuviechadmin/static/'
|
||||
|
||||
def show_debug_toolbar(request):
|
||||
return DEBUG == True and GVA_ENVIRONMENT == "local"
|
||||
return DEBUG == True and GVA_ENVIRONMENT == 'local'
|
||||
|
||||
|
||||
if GVA_ENVIRONMENT == "local":
|
||||
if GVA_ENVIRONMENT == 'local':
|
||||
# ######### DEBUG CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#debug
|
||||
DEBUG = True
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#template-debug
|
||||
TEMPLATES[0]["OPTIONS"]["debug"] = DEBUG
|
||||
TEMPLATES[0]['OPTIONS']['debug'] = DEBUG
|
||||
# ######### END DEBUG CONFIGURATION
|
||||
|
||||
# ######### EMAIL CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#email-backend
|
||||
EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
|
||||
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
|
||||
# ######### END EMAIL CONFIGURATION
|
||||
|
||||
# ######### CACHE CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#caches
|
||||
CACHES = {"default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"}}
|
||||
CACHES = {
|
||||
'default': {
|
||||
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
|
||||
}
|
||||
}
|
||||
# ######### END CACHE CONFIGURATION
|
||||
|
||||
# ######### TOOLBAR CONFIGURATION
|
||||
# See: http://django-debug-toolbar.readthedocs.org/en/latest/installation.html#explicit-setup # noqa
|
||||
INSTALLED_APPS += ("debug_toolbar",)
|
||||
INSTALLED_APPS += (
|
||||
'debug_toolbar',
|
||||
)
|
||||
|
||||
MIDDLEWARE += ["debug_toolbar.middleware.DebugToolbarMiddleware"]
|
||||
MIDDLEWARE += [
|
||||
'debug_toolbar.middleware.DebugToolbarMiddleware',
|
||||
]
|
||||
|
||||
LOGGING["handlers"].update(
|
||||
{
|
||||
"console": {
|
||||
"level": "DEBUG",
|
||||
"class": "logging.StreamHandler",
|
||||
"formatter": "simple",
|
||||
}
|
||||
LOGGING['handlers'].update({
|
||||
'console': {
|
||||
'level': 'DEBUG',
|
||||
'class': 'logging.StreamHandler',
|
||||
'formatter': 'simple',
|
||||
}
|
||||
)
|
||||
LOGGING["loggers"].update(
|
||||
dict(
|
||||
[
|
||||
(key, {"handlers": ["console"], "level": "DEBUG", "propagate": True})
|
||||
for key in [
|
||||
"dashboard",
|
||||
"domains",
|
||||
"fileservertasks",
|
||||
"gvacommon",
|
||||
"gvawebcore",
|
||||
"hostingpackages",
|
||||
"ldaptasks",
|
||||
"managemails",
|
||||
"mysqltasks",
|
||||
"osusers",
|
||||
"pgsqltasks",
|
||||
"taskresults",
|
||||
"userdbs",
|
||||
"websites",
|
||||
]
|
||||
]
|
||||
)
|
||||
)
|
||||
})
|
||||
LOGGING['loggers'].update(dict(
|
||||
[(key, {'handlers': ['console'], 'level': 'DEBUG', 'propagate': True, })
|
||||
for key in [
|
||||
'dashboard', 'domains', 'fileservertasks', 'gvacommon',
|
||||
'gvawebcore', 'hostingpackages', 'ldaptasks', 'managemails',
|
||||
'mysqltasks', 'osusers', 'pgsqltasks', 'taskresults',
|
||||
'userdbs', 'websites']]))
|
||||
|
||||
DEBUG_TOOLBAR_PATCH_SETTINGS = False
|
||||
DEBUG_TOOLBAR_CONFIG = {
|
||||
"SHOW_TOOLBAR_CALLBACK": "gnuviechadmin.settings.show_debug_toolbar"
|
||||
'SHOW_TOOLBAR_CALLBACK': 'gnuviechadmin.settings.show_debug_toolbar',
|
||||
}
|
||||
|
||||
# ######### END TOOLBAR CONFIGURATION
|
||||
elif GVA_ENVIRONMENT == "test":
|
||||
PASSWORD_HASHERS = ("django.contrib.auth.hashers.MD5PasswordHasher",)
|
||||
LOGGING["handlers"].update(
|
||||
{
|
||||
"console": {
|
||||
"level": "ERROR",
|
||||
"class": "logging.StreamHandler",
|
||||
"formatter": "simple",
|
||||
}
|
||||
elif GVA_ENVIRONMENT == 'test':
|
||||
PASSWORD_HASHERS = (
|
||||
'django.contrib.auth.hashers.MD5PasswordHasher',
|
||||
)
|
||||
LOGGING['handlers'].update({
|
||||
'console': {
|
||||
'level': 'ERROR',
|
||||
'class': 'logging.StreamHandler',
|
||||
'formatter': 'simple',
|
||||
}
|
||||
)
|
||||
LOGGING["loggers"].update(
|
||||
dict(
|
||||
[
|
||||
(key, {"handlers": ["console"], "level": "ERROR", "propagate": True})
|
||||
for key in [
|
||||
"dashboard",
|
||||
"domains",
|
||||
"fileservertasks",
|
||||
"gvacommon",
|
||||
"gvawebcore",
|
||||
"hostingpackages",
|
||||
"ldaptasks",
|
||||
"managemails",
|
||||
"mysqltasks",
|
||||
"osusers",
|
||||
"pgsqltasks",
|
||||
"taskresults",
|
||||
"userdbs",
|
||||
"websites",
|
||||
]
|
||||
]
|
||||
)
|
||||
)
|
||||
BROKER_URL = BROKER_URL + "_test"
|
||||
})
|
||||
LOGGING['loggers'].update(dict(
|
||||
[(key, {'handlers': ['console'], 'level': 'ERROR', 'propagate': True, })
|
||||
for key in [
|
||||
'dashboard', 'domains', 'fileservertasks', 'gvacommon',
|
||||
'gvawebcore', 'hostingpackages', 'ldaptasks', 'managemails',
|
||||
'mysqltasks', 'osusers', 'pgsqltasks', 'taskresults',
|
||||
'userdbs', 'websites']]))
|
||||
BROKER_URL = BROKER_URL + '_test'
|
||||
CELERY_RESULT_PERSISTENT = False
|
||||
else:
|
||||
# ######### HOST CONFIGURATION
|
||||
|
@ -474,18 +459,18 @@ else:
|
|||
|
||||
# ######### EMAIL CONFIGURATION
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#email-backend
|
||||
EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
|
||||
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#email-subject-prefix
|
||||
EMAIL_SUBJECT_PREFIX = "[%s] " % SITE_NAME
|
||||
EMAIL_SUBJECT_PREFIX = '[%s] ' % SITE_NAME
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#default-from-email
|
||||
DEFAULT_FROM_EMAIL = get_env_variable(
|
||||
"GVA_SITE_ADMINMAIL", default="admin@example.org"
|
||||
)
|
||||
'GVA_SITE_ADMINMAIL', default='admin@example.org')
|
||||
|
||||
# See: https://docs.djangoproject.com/en/dev/ref/settings/#server-email
|
||||
SERVER_EMAIL = get_env_variable("GVA_SITE_ADMINMAIL", default="admin@example.org")
|
||||
SERVER_EMAIL = get_env_variable(
|
||||
'GVA_SITE_ADMINMAIL', default='admin@example.org')
|
||||
# ######### END EMAIL CONFIGURATION
|
||||
|
||||
# ######### CACHE CONFIGURATION
|
||||
|
@ -494,6 +479,6 @@ else:
|
|||
# ######### END CACHE CONFIGURATION
|
||||
|
||||
# ######### ALLAUTH PRODUCTION CONFIGURATION
|
||||
ACCOUNT_EMAIL_SUBJECT_PREFIX = "[Jan Dittberner IT-Consulting & -Solutions] "
|
||||
ACCOUNT_DEFAULT_HTTP_PROTOCOL = "https"
|
||||
ACCOUNT_EMAIL_SUBJECT_PREFIX = '[Jan Dittberner IT-Consulting & -Solutions] '
|
||||
ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https'
|
||||
# ######### END ALLAUTH PRODUCTION CONFIGURATION
|
||||
|
|
|
@ -5,13 +5,14 @@ This module contains tests for :py:mod:`gnuviechadmin.context_processors`.
|
|||
|
||||
"""
|
||||
|
||||
from unittest.mock import MagicMock
|
||||
from mock import MagicMock
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.http import HttpRequest
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
from gnuviechadmin import __version__ as gvaversion
|
||||
from gnuviechadmin.context_processors import navigation
|
||||
|
@ -21,40 +22,48 @@ User = get_user_model()
|
|||
|
||||
class NavigationContextProcessorTest(TestCase):
|
||||
|
||||
EXPECTED_ITEMS = ("webmail_url", "phpmyadmin_url", "phppgadmin_url", "active_item")
|
||||
EXPECTED_ITEMS = (
|
||||
'webmail_url', 'phpmyadmin_url', 'phppgadmin_url',
|
||||
'active_item'
|
||||
)
|
||||
|
||||
def test_ajax_request(self):
|
||||
response = self.client.get("/", HTTP_X_REQUESTED_WITH="XMLHttpRequest")
|
||||
response = self.client.get(
|
||||
'/', HTTP_X_REQUESTED_WITH='XMLHttpRequest')
|
||||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertNotIn(item, response.context)
|
||||
|
||||
def _check_static_urls(self, context):
|
||||
self.assertEqual(context["webmail_url"], settings.GVA_LINK_WEBMAIL)
|
||||
self.assertEqual(context["phpmyadmin_url"], settings.GVA_LINK_PHPMYADMIN)
|
||||
self.assertEqual(context["phppgadmin_url"], settings.GVA_LINK_PHPPGADMIN)
|
||||
self.assertEqual(
|
||||
context['webmail_url'], settings.GVA_LINK_WEBMAIL)
|
||||
self.assertEqual(
|
||||
context['phpmyadmin_url'], settings.GVA_LINK_PHPMYADMIN)
|
||||
self.assertEqual(
|
||||
context['phppgadmin_url'], settings.GVA_LINK_PHPPGADMIN)
|
||||
|
||||
def test_index_page_context(self):
|
||||
response = self.client.get("/")
|
||||
response = self.client.get('/')
|
||||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertIn(item, response.context)
|
||||
self._check_static_urls(response.context)
|
||||
self.assertEqual(response.context["active_item"], "dashboard")
|
||||
self.assertEqual(response.context['active_item'], 'dashboard')
|
||||
|
||||
def test_contact_page_context(self):
|
||||
response = self.client.get(reverse("contact_form"))
|
||||
response = self.client.get(reverse('contact_form'))
|
||||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertIn(item, response.context)
|
||||
self._check_static_urls(response.context)
|
||||
self.assertEqual(response.context["active_item"], "contact")
|
||||
self.assertEqual(response.context['active_item'], 'contact')
|
||||
|
||||
def test_hostingpackage_page_context(self):
|
||||
User.objects.create_user("test", password="test")
|
||||
self.client.login(username="test", password="test")
|
||||
response = self.client.get(reverse("hosting_packages", kwargs={"user": "test"}))
|
||||
User.objects.create_user('test', password='test')
|
||||
self.client.login(username='test', password='test')
|
||||
response = self.client.get(
|
||||
reverse('hosting_packages', kwargs={'user': 'test'}))
|
||||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertIn(item, response.context)
|
||||
self._check_static_urls(response.context)
|
||||
self.assertEqual(response.context["active_item"], "hostingpackage")
|
||||
self.assertEqual(response.context['active_item'], 'hostingpackage')
|
||||
|
||||
def _test_page_context_by_viewmodule(self, viewmodule, expecteditem):
|
||||
request = HttpRequest()
|
||||
|
@ -64,48 +73,57 @@ class NavigationContextProcessorTest(TestCase):
|
|||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertIn(item, context)
|
||||
self._check_static_urls(context)
|
||||
self.assertEqual(context["active_item"], expecteditem)
|
||||
self.assertEqual(context['active_item'], expecteditem)
|
||||
|
||||
def test_osusers_page_context(self):
|
||||
self._test_page_context_by_viewmodule("osusers.views", "hostingpackage")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'osusers.views', 'hostingpackage')
|
||||
|
||||
def test_userdbs_page_context(self):
|
||||
self._test_page_context_by_viewmodule("userdbs.views", "hostingpackage")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'userdbs.views', 'hostingpackage')
|
||||
|
||||
def test_managemails_page_context(self):
|
||||
self._test_page_context_by_viewmodule("managemails.views", "hostingpackage")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'managemails.views', 'hostingpackage')
|
||||
|
||||
def test_websites_page_context(self):
|
||||
self._test_page_context_by_viewmodule("websites.views", "hostingpackage")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'websites.views', 'hostingpackage')
|
||||
|
||||
def test_domains_page_context(self):
|
||||
self._test_page_context_by_viewmodule("domains.views", "hostingpackage")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'domains.views', 'hostingpackage')
|
||||
|
||||
def test_allauth_account_page_context(self):
|
||||
self._test_page_context_by_viewmodule("allauth.account.views", "account")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'allauth.account.views', 'account')
|
||||
|
||||
def test_allauth_socialaccount_page_context(self):
|
||||
self._test_page_context_by_viewmodule("allauth.socialaccount.views", "account")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'allauth.socialaccount.views', 'account')
|
||||
|
||||
def test_imprint_page_context(self):
|
||||
response = self.client.get(reverse("imprint"))
|
||||
response = self.client.get(reverse('imprint'))
|
||||
for item in self.EXPECTED_ITEMS:
|
||||
self.assertIn(item, response.context)
|
||||
self._check_static_urls(response.context)
|
||||
self.assertEqual(response.context["active_item"], "imprint")
|
||||
self.assertEqual(response.context['active_item'], 'imprint')
|
||||
|
||||
def test_no_resolver_match(self):
|
||||
request = HttpRequest()
|
||||
context = navigation(request)
|
||||
self._check_static_urls(context)
|
||||
self.assertEqual(context["active_item"], "dashboard")
|
||||
self.assertEqual(context['active_item'], 'dashboard')
|
||||
|
||||
def test_admin_module(self):
|
||||
self._test_page_context_by_viewmodule("django.contrib.admin.foo", "dashboard")
|
||||
self._test_page_context_by_viewmodule(
|
||||
'django.contrib.admin.foo', 'dashboard')
|
||||
|
||||
|
||||
class VersionInfoContextProcessorTest(TestCase):
|
||||
|
||||
def test_version_info_in_context(self):
|
||||
response = self.client.get("/")
|
||||
self.assertIn("gnuviechadmin_version", response.context)
|
||||
self.assertEqual(response.context["gnuviechadmin_version"], gvaversion)
|
||||
response = self.client.get('/')
|
||||
self.assertIn('gnuviechadmin_version', response.context)
|
||||
self.assertEqual(response.context['gnuviechadmin_version'], gvaversion)
|
||||
|
|
|
@ -5,26 +5,25 @@ This module contains tests for :py:mod:`gvawebcore.forms`.
|
|||
|
||||
from unittest import TestCase
|
||||
|
||||
from gvawebcore.forms import PASSWORD_MISMATCH_ERROR, PasswordModelFormMixin
|
||||
from gvawebcore.forms import PasswordModelFormMixin, PASSWORD_MISMATCH_ERROR
|
||||
|
||||
|
||||
class PasswordModelFormMixinTest(TestCase):
|
||||
|
||||
def test_form_properties(self):
|
||||
form = PasswordModelFormMixin()
|
||||
self.assertIn("password1", form.fields)
|
||||
self.assertIn("password2", form.fields)
|
||||
self.assertIn('password1', form.fields)
|
||||
self.assertIn('password2', form.fields)
|
||||
|
||||
def test_clean_password_same(self):
|
||||
form = PasswordModelFormMixin(
|
||||
data={"password1": "secret", "password2": "secret"}
|
||||
)
|
||||
form = PasswordModelFormMixin(data={
|
||||
'password1': 'secret', 'password2': 'secret'})
|
||||
self.assertTrue(form.is_valid())
|
||||
self.assertEqual("secret", form.clean_password2())
|
||||
self.assertEqual('secret', form.clean_password2())
|
||||
|
||||
def test_clean_password_different(self):
|
||||
form = PasswordModelFormMixin(
|
||||
data={"password1": "onesecret", "password2": "other"}
|
||||
)
|
||||
form = PasswordModelFormMixin(data={
|
||||
'password1': 'onesecret', 'password2': 'other'})
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("password2", form.errors)
|
||||
self.assertIn(PASSWORD_MISMATCH_ERROR, form.errors["password2"])
|
||||
self.assertIn('password2', form.errors)
|
||||
self.assertIn(PASSWORD_MISMATCH_ERROR, form.errors['password2'])
|
||||
|
|
|
@ -4,29 +4,31 @@ This model contains tests for :py:mod:`gvawebcore.views`.
|
|||
"""
|
||||
|
||||
from unittest import TestCase
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from mock import patch, Mock
|
||||
|
||||
from gvawebcore.views import HostingPackageAndCustomerMixin
|
||||
|
||||
|
||||
class HostingPackageAndCustomerMixinTest(TestCase):
|
||||
|
||||
class TestView(HostingPackageAndCustomerMixin):
|
||||
|
||||
kwargs = {"package": "1"}
|
||||
kwargs = {'package': '1'}
|
||||
|
||||
@patch("gvawebcore.views.get_object_or_404")
|
||||
@patch('gvawebcore.views.get_object_or_404')
|
||||
def test_get_hosting_package(self, get_object_or_404):
|
||||
get_object_or_404.return_value = "A package"
|
||||
get_object_or_404.return_value = 'A package'
|
||||
view = self.TestView()
|
||||
self.assertEqual("A package", view.get_hosting_package())
|
||||
self.assertEqual('A package', view.get_hosting_package())
|
||||
|
||||
def test_get_hosting_package_cached(self):
|
||||
view = self.TestView()
|
||||
view.hostingpackage = "Cached package"
|
||||
self.assertEqual("Cached package", view.get_hosting_package())
|
||||
view.hostingpackage = 'Cached package'
|
||||
self.assertEqual('Cached package', view.get_hosting_package())
|
||||
|
||||
@patch("gvawebcore.views.get_object_or_404")
|
||||
@patch('gvawebcore.views.get_object_or_404')
|
||||
def test_get_customer_object(self, get_object_or_404):
|
||||
get_object_or_404.return_value = Mock(customer="A customer")
|
||||
get_object_or_404.return_value = Mock(customer='A customer')
|
||||
view = self.TestView()
|
||||
self.assertEqual("A customer", view.get_customer_object())
|
||||
self.assertEqual('A customer', view.get_customer_object())
|
||||
|
|
|
@ -16,24 +16,37 @@ from model_utils.models import TimeStampedModel
|
|||
|
||||
from domains.models import HostingDomain
|
||||
from managemails.models import Mailbox
|
||||
from osusers.models import AdditionalGroup, Group, User as OsUser
|
||||
from userdbs.models import DB_TYPES, UserDatabase
|
||||
from osusers.models import (
|
||||
AdditionalGroup,
|
||||
Group,
|
||||
User as OsUser,
|
||||
)
|
||||
from userdbs.models import (
|
||||
DB_TYPES,
|
||||
UserDatabase,
|
||||
)
|
||||
|
||||
DISK_SPACE_UNITS = Choices((0, "M", _("MiB")), (1, "G", _("GiB")), (2, "T", _("TiB")))
|
||||
DISK_SPACE_UNITS = Choices(
|
||||
(0, 'M', _('MiB')),
|
||||
(1, 'G', _('GiB')),
|
||||
(2, 'T', _('TiB')),
|
||||
)
|
||||
|
||||
DISK_SPACE_FACTORS = ((1, None, None), (1024, 1, None), (1024 * 1024, 1024, 1))
|
||||
DISK_SPACE_FACTORS = (
|
||||
(1, None, None),
|
||||
(1024, 1, None),
|
||||
(1024 * 1024, 1024, 1),
|
||||
)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class HostingPackageBase(TimeStampedModel):
|
||||
description = models.TextField(_("description"), blank=True)
|
||||
mailboxcount = models.PositiveIntegerField(_("mailbox count"))
|
||||
description = models.TextField(_('description'), blank=True)
|
||||
mailboxcount = models.PositiveIntegerField(_('mailbox count'))
|
||||
diskspace = models.PositiveIntegerField(
|
||||
_("disk space"), help_text=_("disk space for the hosting package")
|
||||
)
|
||||
_('disk space'), help_text=_('disk space for the hosting package'))
|
||||
diskspace_unit = models.PositiveSmallIntegerField(
|
||||
_("unit of disk space"), choices=DISK_SPACE_UNITS
|
||||
)
|
||||
_('unit of disk space'), choices=DISK_SPACE_UNITS)
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
|
@ -43,11 +56,11 @@ class HostingPackageBase(TimeStampedModel):
|
|||
|
||||
|
||||
class HostingPackageTemplate(HostingPackageBase):
|
||||
name = models.CharField(_("name"), max_length=128, unique=True)
|
||||
name = models.CharField(_('name'), max_length=128, unique=True)
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("Hosting package")
|
||||
verbose_name_plural = _("Hosting packages")
|
||||
verbose_name = _('Hosting package')
|
||||
verbose_name_plural = _('Hosting packages')
|
||||
|
||||
|
||||
class HostingOption(TimeStampedModel):
|
||||
|
@ -59,21 +72,19 @@ class HostingOption(TimeStampedModel):
|
|||
|
||||
@python_2_unicode_compatible
|
||||
class DiskSpaceOptionBase(models.Model):
|
||||
diskspace = models.PositiveIntegerField(_("disk space"))
|
||||
diskspace = models.PositiveIntegerField(_('disk space'))
|
||||
diskspace_unit = models.PositiveSmallIntegerField(
|
||||
_("unit of disk space"), choices=DISK_SPACE_UNITS
|
||||
)
|
||||
_('unit of disk space'), choices=DISK_SPACE_UNITS)
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
ordering = ["diskspace_unit", "diskspace"]
|
||||
verbose_name = _("Disk space option")
|
||||
verbose_name_plural = _("Disk space options")
|
||||
ordering = ['diskspace_unit', 'diskspace']
|
||||
verbose_name = _('Disk space option')
|
||||
verbose_name_plural = _('Disk space options')
|
||||
|
||||
def __str__(self):
|
||||
return _("Additional disk space {space} {unit}").format(
|
||||
space=self.diskspace, unit=self.get_diskspace_unit_display()
|
||||
)
|
||||
space=self.diskspace, unit=self.get_diskspace_unit_display())
|
||||
|
||||
|
||||
class DiskSpaceOption(DiskSpaceOptionBase, HostingOption):
|
||||
|
@ -84,24 +95,30 @@ class DiskSpaceOption(DiskSpaceOptionBase, HostingOption):
|
|||
"""
|
||||
|
||||
class Meta:
|
||||
unique_together = ["diskspace", "diskspace_unit"]
|
||||
unique_together = ['diskspace', 'diskspace_unit']
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class UserDatabaseOptionBase(models.Model):
|
||||
number = models.PositiveIntegerField(_("number of databases"), default=1)
|
||||
db_type = models.PositiveSmallIntegerField(_("database type"), choices=DB_TYPES)
|
||||
number = models.PositiveIntegerField(
|
||||
_('number of databases'), default=1)
|
||||
db_type = models.PositiveSmallIntegerField(
|
||||
_('database type'), choices=DB_TYPES)
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
ordering = ["db_type", "number"]
|
||||
verbose_name = _("Database option")
|
||||
verbose_name_plural = _("Database options")
|
||||
ordering = ['db_type', 'number']
|
||||
verbose_name = _('Database option')
|
||||
verbose_name_plural = _('Database options')
|
||||
|
||||
def __str__(self):
|
||||
return ungettext(
|
||||
"{type} database", "{count} {type} databases", self.number
|
||||
).format(type=self.get_db_type_display(), count=self.number)
|
||||
'{type} database',
|
||||
'{count} {type} databases',
|
||||
self.number
|
||||
).format(
|
||||
type=self.get_db_type_display(), count=self.number
|
||||
)
|
||||
|
||||
|
||||
class UserDatabaseOption(UserDatabaseOptionBase, HostingOption):
|
||||
|
@ -112,7 +129,7 @@ class UserDatabaseOption(UserDatabaseOptionBase, HostingOption):
|
|||
"""
|
||||
|
||||
class Meta:
|
||||
unique_together = ["number", "db_type"]
|
||||
unique_together = ['number', 'db_type']
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
|
@ -121,19 +138,23 @@ class MailboxOptionBase(models.Model):
|
|||
Base class for mailbox options.
|
||||
|
||||
"""
|
||||
|
||||
number = models.PositiveIntegerField(_("number of mailboxes"), unique=True)
|
||||
number = models.PositiveIntegerField(
|
||||
_('number of mailboxes'), unique=True)
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
ordering = ["number"]
|
||||
verbose_name = _("Mailbox option")
|
||||
verbose_name_plural = _("Mailbox options")
|
||||
ordering = ['number']
|
||||
verbose_name = _('Mailbox option')
|
||||
verbose_name_plural = _('Mailbox options')
|
||||
|
||||
def __str__(self):
|
||||
return ungettext(
|
||||
"{count} additional mailbox", "{count} additional mailboxes", self.number
|
||||
).format(count=self.number)
|
||||
'{count} additional mailbox',
|
||||
'{count} additional mailboxes',
|
||||
self.number
|
||||
).format(
|
||||
count=self.number
|
||||
)
|
||||
|
||||
|
||||
class MailboxOption(MailboxOptionBase, HostingOption):
|
||||
|
@ -168,11 +189,10 @@ class CustomerHostingPackageManager(models.Manager):
|
|||
|
||||
"""
|
||||
package = CustomerHostingPackage(
|
||||
customer=customer, template=template, name=name
|
||||
)
|
||||
customer=customer, template=template, name=name)
|
||||
package.description = template.description
|
||||
package.copy_template_attributes()
|
||||
if "commit" in kwargs and kwargs["commit"] is True:
|
||||
if 'commit' in kwargs and kwargs['commit'] is True:
|
||||
package.save(**kwargs)
|
||||
return package
|
||||
|
||||
|
@ -183,49 +203,45 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
This class defines customer specific hosting packages.
|
||||
|
||||
"""
|
||||
|
||||
customer = models.ForeignKey(
|
||||
settings.AUTH_USER_MODEL, verbose_name=_("customer"), on_delete=models.CASCADE
|
||||
)
|
||||
settings.AUTH_USER_MODEL, verbose_name=_('customer'),
|
||||
on_delete=models.CASCADE)
|
||||
template = models.ForeignKey(
|
||||
HostingPackageTemplate,
|
||||
verbose_name=_("hosting package template"),
|
||||
HostingPackageTemplate, verbose_name=_('hosting package template'),
|
||||
help_text=_(
|
||||
"The hosting package template that this hosting package is based" " on"
|
||||
'The hosting package template that this hosting package is based'
|
||||
' on'
|
||||
),
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
name = models.CharField(_("name"), max_length=128)
|
||||
on_delete=models.CASCADE)
|
||||
name = models.CharField(_('name'), max_length=128)
|
||||
osuser = models.OneToOneField(
|
||||
OsUser,
|
||||
verbose_name=_("Operating system user"),
|
||||
blank=True,
|
||||
null=True,
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
OsUser, verbose_name=_('Operating system user'),
|
||||
blank=True, null=True, on_delete=models.CASCADE)
|
||||
|
||||
objects = CustomerHostingPackageManager()
|
||||
|
||||
class Meta:
|
||||
unique_together = ["customer", "name"]
|
||||
verbose_name = _("customer hosting package")
|
||||
verbose_name_plural = _("customer hosting packages")
|
||||
unique_together = ['customer', 'name']
|
||||
verbose_name = _('customer hosting package')
|
||||
verbose_name_plural = _('customer hosting packages')
|
||||
|
||||
def __str__(self):
|
||||
return _("{name} for {customer}").format(name=self.name, customer=self.customer)
|
||||
return _("{name} for {customer}").format(
|
||||
name=self.name, customer=self.customer
|
||||
)
|
||||
|
||||
def get_absolute_url(self):
|
||||
return reverse(
|
||||
"hosting_package_details",
|
||||
kwargs={"user": self.customer.username, "pk": self.id},
|
||||
)
|
||||
return reverse('hosting_package_details', kwargs={
|
||||
'user': self.customer.username,
|
||||
'pk': self.id,
|
||||
})
|
||||
|
||||
def copy_template_attributes(self):
|
||||
"""
|
||||
Copy the attributes of the hosting package's template to the package.
|
||||
|
||||
"""
|
||||
for attrname in ("diskspace", "diskspace_unit", "mailboxcount"):
|
||||
for attrname in ('diskspace', 'diskspace_unit', 'mailboxcount'):
|
||||
setattr(self, attrname, getattr(self.template, attrname))
|
||||
|
||||
def get_hostingoptions(self):
|
||||
|
@ -233,7 +249,7 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
for opt_type in [
|
||||
CustomerDiskSpaceOption,
|
||||
CustomerMailboxOption,
|
||||
CustomerUserDatabaseOption,
|
||||
CustomerUserDatabaseOption
|
||||
]:
|
||||
opts.extend(opt_type.objects.filter(hosting_package=self))
|
||||
return opts
|
||||
|
@ -260,13 +276,13 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
diskspace += option.diskspace
|
||||
elif option.diskspace_unit > min_unit:
|
||||
diskspace += (
|
||||
DISK_SPACE_FACTORS[option.diskspace_unit][min_unit]
|
||||
* option.diskspace
|
||||
)
|
||||
DISK_SPACE_FACTORS[option.diskspace_unit][min_unit] *
|
||||
option.diskspace)
|
||||
else:
|
||||
diskspace = (
|
||||
DISK_SPACE_FACTORS[min_unit][option.diskspace_unit] * diskspace
|
||||
) + option.diskspace
|
||||
DISK_SPACE_FACTORS[min_unit][
|
||||
option.diskspace_unit] *
|
||||
diskspace) + option.diskspace
|
||||
min_unit = option.diskspace_unit
|
||||
if unit is None:
|
||||
return DISK_SPACE_FACTORS[min_unit][0] * diskspace * 1024 ** 2
|
||||
|
@ -286,16 +302,16 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
|
||||
"""
|
||||
if unit is None:
|
||||
return (
|
||||
DISK_SPACE_FACTORS[self.diskspace_unit][0] * self.diskspace * 1024 ** 2
|
||||
)
|
||||
return (DISK_SPACE_FACTORS[self.diskspace_unit][0] *
|
||||
self.diskspace * 1024 ** 2)
|
||||
if unit > self.diskspace_unit:
|
||||
return DISK_SPACE_FACTORS[unit][self.diskspace_unit] * self.diskspace
|
||||
return (DISK_SPACE_FACTORS[unit][self.diskspace_unit] *
|
||||
self.diskspace)
|
||||
return DISK_SPACE_FACTORS[self.diskspace_unit][unit] * self.diskspace
|
||||
|
||||
def get_quota(self):
|
||||
soft = 1024 * self.get_disk_space(DISK_SPACE_UNITS.M)
|
||||
hard = soft * 105 // 100
|
||||
hard = soft * 105 / 100
|
||||
return (soft, hard)
|
||||
|
||||
def get_mailboxes(self):
|
||||
|
@ -321,10 +337,12 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
of its mailbox options.
|
||||
|
||||
"""
|
||||
result = CustomerMailboxOption.objects.filter(hosting_package=self).aggregate(
|
||||
mailbox_sum=models.Sum("number")
|
||||
result = CustomerMailboxOption.objects.filter(
|
||||
hosting_package=self
|
||||
).aggregate(
|
||||
mailbox_sum=models.Sum('number')
|
||||
)
|
||||
return self.mailboxcount + (result["mailbox_sum"] or 0)
|
||||
return self.mailboxcount + (result['mailbox_sum'] or 0)
|
||||
|
||||
mailbox_count = property(get_mailbox_count)
|
||||
|
||||
|
@ -337,23 +355,25 @@ class CustomerHostingPackage(HostingPackageBase):
|
|||
options for this hosting package.
|
||||
|
||||
"""
|
||||
return (
|
||||
CustomerUserDatabaseOption.objects.values("db_type")
|
||||
.filter(hosting_package=self)
|
||||
.annotate(number=models.Sum("number"))
|
||||
.all()
|
||||
)
|
||||
return CustomerUserDatabaseOption.objects.values(
|
||||
'db_type'
|
||||
).filter(hosting_package=self).annotate(
|
||||
number=models.Sum('number')
|
||||
).all()
|
||||
|
||||
def get_databases_flat(self):
|
||||
if self.osuser:
|
||||
return UserDatabase.objects.filter(db_user__osuser=self.osuser).all()
|
||||
return UserDatabase.objects.filter(
|
||||
db_user__osuser=self.osuser).all()
|
||||
|
||||
databases = property(get_databases_flat)
|
||||
|
||||
def may_add_database(self):
|
||||
return (
|
||||
CustomerUserDatabaseOption.objects.filter(hosting_package=self).count()
|
||||
> UserDatabase.objects.filter(db_user__osuser=self.osuser).count()
|
||||
CustomerUserDatabaseOption.objects.filter(
|
||||
hosting_package=self).count() >
|
||||
UserDatabase.objects.filter(
|
||||
db_user__osuser=self.osuser).count()
|
||||
)
|
||||
|
||||
@transaction.atomic
|
||||
|
@ -389,16 +409,12 @@ class CustomerHostingPackageDomain(TimeStampedModel):
|
|||
domain.
|
||||
|
||||
"""
|
||||
|
||||
hosting_package = models.ForeignKey(
|
||||
CustomerHostingPackage,
|
||||
verbose_name=_("hosting package"),
|
||||
related_name="domains",
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
CustomerHostingPackage, verbose_name=_('hosting package'),
|
||||
related_name='domains', on_delete=models.CASCADE)
|
||||
domain = models.OneToOneField(
|
||||
HostingDomain, verbose_name=_("hosting domain"), on_delete=models.CASCADE
|
||||
)
|
||||
HostingDomain, verbose_name=_('hosting domain'),
|
||||
on_delete=models.CASCADE)
|
||||
|
||||
def __str__(self):
|
||||
return self.domain.domain
|
||||
|
@ -416,62 +432,60 @@ class CustomerHostingPackageOption(TimeStampedModel):
|
|||
This class defines options for customer hosting packages.
|
||||
|
||||
"""
|
||||
|
||||
hosting_package = models.ForeignKey(
|
||||
CustomerHostingPackage,
|
||||
verbose_name=_("hosting package"),
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
CustomerHostingPackage, verbose_name=_('hosting package'),
|
||||
on_delete=models.CASCADE)
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("customer hosting option")
|
||||
verbose_name_plural = _("customer hosting options")
|
||||
verbose_name = _('customer hosting option')
|
||||
verbose_name_plural = _('customer hosting options')
|
||||
|
||||
|
||||
class CustomerDiskSpaceOption(DiskSpaceOptionBase, CustomerHostingPackageOption):
|
||||
class CustomerDiskSpaceOption(DiskSpaceOptionBase,
|
||||
CustomerHostingPackageOption):
|
||||
"""
|
||||
This is a class for customer hosting package options adding additional disk
|
||||
space to existing customer hosting package.
|
||||
|
||||
"""
|
||||
|
||||
template = models.ForeignKey(
|
||||
DiskSpaceOption,
|
||||
verbose_name=_("disk space option template"),
|
||||
verbose_name=_('disk space option template'),
|
||||
help_text=_(
|
||||
"The disk space option template that this disk space option is" " based on"
|
||||
'The disk space option template that this disk space option is'
|
||||
' based on'
|
||||
),
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
on_delete=models.CASCADE)
|
||||
|
||||
|
||||
class CustomerUserDatabaseOption(UserDatabaseOptionBase, CustomerHostingPackageOption):
|
||||
class CustomerUserDatabaseOption(UserDatabaseOptionBase,
|
||||
CustomerHostingPackageOption):
|
||||
"""
|
||||
This is a class for customer hosting package options adding user databases
|
||||
to existing customer hosting packages.
|
||||
|
||||
"""
|
||||
|
||||
template = models.ForeignKey(
|
||||
UserDatabaseOption,
|
||||
verbose_name=_("user database option template"),
|
||||
verbose_name=_('user database option template'),
|
||||
help_text=_(
|
||||
"The user database option template that this database option is" " based on"
|
||||
'The user database option template that this database option is'
|
||||
' based on'
|
||||
),
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
on_delete=models.CASCADE)
|
||||
|
||||
|
||||
class CustomerMailboxOption(MailboxOptionBase, CustomerHostingPackageOption):
|
||||
class CustomerMailboxOption(MailboxOptionBase,
|
||||
CustomerHostingPackageOption):
|
||||
"""
|
||||
This is a class for customer hosting package options adding additional
|
||||
mailboxes to existing customer hosting packages.
|
||||
|
||||
"""
|
||||
|
||||
template = models.ForeignKey(
|
||||
MailboxOption,
|
||||
verbose_name=_("mailbox option template"),
|
||||
help_text=_("The mailbox option template that this mailbox option is based on"),
|
||||
on_delete=models.CASCADE,
|
||||
)
|
||||
verbose_name=_('mailbox option template'),
|
||||
help_text=_(
|
||||
'The mailbox option template that this mailbox option is based on'
|
||||
),
|
||||
on_delete=models.CASCADE)
|
||||
|
|
|
@ -5,7 +5,10 @@ Test for models.
|
|||
|
||||
from django.test import TestCase
|
||||
|
||||
from hostingpackages.models import DISK_SPACE_UNITS, CustomerHostingPackage
|
||||
from hostingpackages.models import (
|
||||
DISK_SPACE_UNITS,
|
||||
CustomerHostingPackage,
|
||||
)
|
||||
|
||||
|
||||
class CustomerHostingPackageTest(TestCase):
|
||||
|
@ -13,7 +16,7 @@ class CustomerHostingPackageTest(TestCase):
|
|||
package = CustomerHostingPackage(
|
||||
diskspace=10, diskspace_unit=DISK_SPACE_UNITS.G
|
||||
)
|
||||
self.assertEqual(package.get_disk_space(), 10 * 1024 ** 3)
|
||||
self.assertEqual(package.get_disk_space(), 10 * 1024 * 1024**2)
|
||||
|
||||
def test_get_disk_space_mib(self):
|
||||
package = CustomerHostingPackage(
|
||||
|
|
|
@ -4,7 +4,7 @@ import sys
|
|||
|
||||
if __name__ == "__main__":
|
||||
os.environ.setdefault(
|
||||
"DJANGO_SETTINGS_MODULE", "gnuviechadmin.settings")
|
||||
"DJANGO_SETTINGS_MODULE", "gnuviechadmin.settings.local")
|
||||
|
||||
from django.core.management import execute_from_command_line
|
||||
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
from django import forms
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
from django.urls import reverse
|
||||
from django.utils.html import format_html
|
||||
from django.utils.translation import ugettext as _
|
||||
|
||||
from django.contrib.admin import AdminSite
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
from unittest.mock import Mock
|
||||
from mock import Mock
|
||||
|
||||
from osusers.models import User
|
||||
|
||||
|
@ -21,7 +21,9 @@ from managemails.admin import (
|
|||
ReadOnlyPasswordHashField,
|
||||
ReadOnlyPasswordHashWidget,
|
||||
)
|
||||
from managemails.models import Mailbox
|
||||
from managemails.models import (
|
||||
Mailbox,
|
||||
)
|
||||
|
||||
Customer = get_user_model()
|
||||
|
||||
|
@ -29,14 +31,14 @@ Customer = get_user_model()
|
|||
class ReadOnlyPasswordHashWidgetTest(TestCase):
|
||||
def test_render(self):
|
||||
widget = ReadOnlyPasswordHashWidget()
|
||||
rendered = widget.render("password", "secret", {"class": "test"})
|
||||
rendered = widget.render('password', 'secret', {'class': 'test'})
|
||||
self.assertEqual(
|
||||
rendered,
|
||||
format_html(
|
||||
'<div class="test">{0}</div>',
|
||||
format_html("<strong>{0}</strong>: secret ", _("Hash")),
|
||||
),
|
||||
)
|
||||
format_html('<strong>{0}</strong>: secret ',
|
||||
_('Hash'))
|
||||
))
|
||||
|
||||
|
||||
class ReadOnlyPasswordHashFieldTest(TestCase):
|
||||
|
@ -46,24 +48,24 @@ class ReadOnlyPasswordHashFieldTest(TestCase):
|
|||
|
||||
def test_bound_data(self):
|
||||
field = ReadOnlyPasswordHashField()
|
||||
self.assertEqual(field.bound_data("new", "old"), "old")
|
||||
self.assertEqual(field.bound_data('new', 'old'), 'old')
|
||||
|
||||
def test__has_changed(self):
|
||||
field = ReadOnlyPasswordHashField()
|
||||
self.assertFalse(field.has_changed("new", "old"))
|
||||
self.assertFalse(field.has_changed('new', 'old'))
|
||||
|
||||
|
||||
class CustomerTestCase(TestCase):
|
||||
def setUp(self):
|
||||
super(CustomerTestCase, self).setUp()
|
||||
self.customer = Customer.objects.create(username="test")
|
||||
self.customer = Customer.objects.create(username='test')
|
||||
|
||||
|
||||
class MailboxCreationFormTest(CustomerTestCase):
|
||||
def test_clean_password2_same(self):
|
||||
form = MailboxCreationForm()
|
||||
form.cleaned_data = {"password1": "secret", "password2": "secret"}
|
||||
self.assertEqual(form.clean_password2(), "secret")
|
||||
form.cleaned_data = {'password1': 'secret', 'password2': 'secret'}
|
||||
self.assertEqual(form.clean_password2(), 'secret')
|
||||
|
||||
def test_clean_password2_empty(self):
|
||||
form = MailboxCreationForm()
|
||||
|
@ -72,47 +74,59 @@ class MailboxCreationFormTest(CustomerTestCase):
|
|||
|
||||
def test_clean_password2_mismatch(self):
|
||||
form = MailboxCreationForm()
|
||||
form.cleaned_data = {"password1": "secretx", "password2": "secrety"}
|
||||
form.cleaned_data = {'password1': 'secretx', 'password2': 'secrety'}
|
||||
with self.assertRaises(forms.ValidationError) as cm:
|
||||
form.clean_password2()
|
||||
self.assertEqual(cm.exception.message, PASSWORD_MISMATCH_ERROR)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_save_commit(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
form = MailboxCreationForm(
|
||||
data={"osuser": user.uid, "password1": "secret", "password2": "secret"}
|
||||
)
|
||||
form = MailboxCreationForm(data={
|
||||
'osuser': user.uid,
|
||||
'password1': 'secret',
|
||||
'password2': 'secret',
|
||||
})
|
||||
mailbox = form.save()
|
||||
self.assertIsNotNone(mailbox)
|
||||
self.assertEqual(len(Mailbox.objects.filter(osuser=user)), 1)
|
||||
self.assertEqual(
|
||||
len(Mailbox.objects.filter(osuser=user)), 1)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_save_no_commit(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
form = MailboxCreationForm(
|
||||
data={"osuser": user.uid, "password1": "secret", "password2": "secret"}
|
||||
)
|
||||
form = MailboxCreationForm(data={
|
||||
'osuser': user.uid,
|
||||
'password1': 'secret',
|
||||
'password2': 'secret',
|
||||
})
|
||||
mailbox = form.save(commit=False)
|
||||
self.assertIsNotNone(mailbox)
|
||||
self.assertEqual(len(Mailbox.objects.filter(osuser=user)), 0)
|
||||
self.assertEqual(
|
||||
len(Mailbox.objects.filter(osuser=user)), 0)
|
||||
|
||||
|
||||
class MailboxChangeFormTest(CustomerTestCase):
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_clean_password(self):
|
||||
mailbox = Mailbox(
|
||||
username="test", osuser=User.objects.create_user(customer=self.customer)
|
||||
)
|
||||
mailbox.set_password("test")
|
||||
username='test',
|
||||
osuser=User.objects.create_user(customer=self.customer))
|
||||
mailbox.set_password('test')
|
||||
mailbox.save()
|
||||
form = MailboxChangeForm(instance=mailbox, data={"password": "blub"})
|
||||
form = MailboxChangeForm(instance=mailbox, data={'password': 'blub'})
|
||||
self.assertEqual(form.clean_password(), mailbox.password)
|
||||
|
||||
|
||||
|
@ -137,43 +151,55 @@ class MailBoxAdminTest(CustomerTestCase):
|
|||
self.mbadmin = MailboxAdmin(Mailbox, site)
|
||||
|
||||
def test_get_fieldsets_without_object(self):
|
||||
self.assertEqual(self.mbadmin.get_fieldsets(Mock()), self.mbadmin.add_fieldsets)
|
||||
self.assertEqual(
|
||||
self.mbadmin.get_fieldsets(Mock()),
|
||||
self.mbadmin.add_fieldsets)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_get_fieldsets_with_object(self):
|
||||
mailbox = Mailbox(
|
||||
username="test", osuser=User.objects.create_user(customer=self.customer)
|
||||
)
|
||||
mailbox.set_password("test")
|
||||
username='test',
|
||||
osuser=User.objects.create_user(customer=self.customer))
|
||||
mailbox.set_password('test')
|
||||
mailbox.save()
|
||||
self.assertEqual(
|
||||
self.mbadmin.get_fieldsets(Mock(), mailbox), self.mbadmin.fieldsets
|
||||
)
|
||||
self.mbadmin.get_fieldsets(Mock(), mailbox),
|
||||
self.mbadmin.fieldsets)
|
||||
|
||||
def test_get_form_without_object(self):
|
||||
form = self.mbadmin.get_form(Mock)
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "password1", "password2"])
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'password1', 'password2']
|
||||
)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_get_form_with_object(self):
|
||||
mailbox = Mailbox(
|
||||
username="test", osuser=User.objects.create_user(customer=self.customer)
|
||||
)
|
||||
mailbox.set_password("test")
|
||||
username='test',
|
||||
osuser=User.objects.create_user(customer=self.customer))
|
||||
mailbox.set_password('test')
|
||||
mailbox.save()
|
||||
form = self.mbadmin.get_form(Mock, mailbox)
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "username", "password", "active"])
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'username', 'password', 'active']
|
||||
)
|
||||
|
||||
def test_admin_for_mailbox(self):
|
||||
admin_url = reverse("admin:managemails_mailaddress_changelist")
|
||||
admin_url = reverse('admin:managemails_mailaddress_changelist')
|
||||
self.assertIsNotNone(admin_url)
|
||||
|
||||
|
||||
class MailAddressAdminTest(TestCase):
|
||||
def test_admin_for_mailaddress(self):
|
||||
admin_url = reverse("admin:managemails_mailaddress_changelist")
|
||||
admin_url = reverse('admin:managemails_mailaddress_changelist')
|
||||
self.assertIsNotNone(admin_url)
|
||||
|
|
|
@ -2,11 +2,13 @@
|
|||
This module provides tests for :py:mod:`managemails.forms`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, Mock, patch, ANY
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from mock import MagicMock, Mock, patch, ANY
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.forms import ValidationError
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from managemails.forms import (
|
||||
AddMailAddressForm,
|
||||
|
@ -20,6 +22,7 @@ from managemails.forms import (
|
|||
|
||||
|
||||
class CreateMailboxFormTest(TestCase):
|
||||
|
||||
def test_constructor_needs_hostingpackage(self):
|
||||
instance = MagicMock()
|
||||
with self.assertRaises(KeyError):
|
||||
|
@ -29,35 +32,33 @@ class CreateMailboxFormTest(TestCase):
|
|||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock()
|
||||
form = CreateMailboxForm(instance, hostingpackage=hostingpackage)
|
||||
self.assertTrue(hasattr(form, "hosting_package"))
|
||||
self.assertTrue(hasattr(form, 'hosting_package'))
|
||||
self.assertEqual(form.hosting_package, hostingpackage)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action, reverse("create_mailbox", kwargs={"package": 42})
|
||||
)
|
||||
self.assertIn("password1", form.fields)
|
||||
self.assertIn("password2", form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'create_mailbox', kwargs={'package': 42}))
|
||||
self.assertIn('password1', form.fields)
|
||||
self.assertIn('password2', form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
@patch("managemails.forms.Mailbox.objects")
|
||||
@patch('managemails.forms.Mailbox.objects')
|
||||
def test_save(self, mailbox_objects):
|
||||
osuser = MagicMock()
|
||||
hostingpackage = Mock(id=42, osuser=osuser)
|
||||
instance = MagicMock()
|
||||
form = CreateMailboxForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
data={"password1": "secret", "password2": "secret"},
|
||||
)
|
||||
mailbox_objects.get_next_mailbox_name.return_value = "mailbox23"
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
data={'password1': 'secret', 'password2': 'secret'})
|
||||
mailbox_objects.get_next_mailbox_name.return_value = 'mailbox23'
|
||||
self.assertTrue(form.is_valid())
|
||||
form.save(commit=False)
|
||||
self.assertEqual(osuser, form.instance.osuser)
|
||||
self.assertEqual("mailbox23", form.instance.username)
|
||||
instance.set_password.assert_called_with("secret")
|
||||
self.assertEqual('mailbox23', form.instance.username)
|
||||
instance.set_password.assert_called_with('secret')
|
||||
|
||||
|
||||
class ChangeMailboxPasswordFormTest(TestCase):
|
||||
|
||||
def test_constructor_needs_hostingpackage(self):
|
||||
instance = MagicMock()
|
||||
with self.assertRaises(KeyError):
|
||||
|
@ -65,75 +66,72 @@ class ChangeMailboxPasswordFormTest(TestCase):
|
|||
|
||||
def test_constructor(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock(username="testuser")
|
||||
instance = MagicMock(username='testuser')
|
||||
form = ChangeMailboxPasswordForm(
|
||||
instance=instance, hostingpackage=hostingpackage
|
||||
)
|
||||
self.assertTrue(hasattr(form, "hosting_package"))
|
||||
instance=instance, hostingpackage=hostingpackage)
|
||||
self.assertTrue(hasattr(form, 'hosting_package'))
|
||||
self.assertEqual(form.hosting_package, hostingpackage)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse(
|
||||
"change_mailbox_password", kwargs={"package": 42, "slug": "testuser"}
|
||||
),
|
||||
)
|
||||
self.assertIn("password1", form.fields)
|
||||
self.assertIn("password2", form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'change_mailbox_password', kwargs={
|
||||
'package': 42, 'slug': 'testuser'}))
|
||||
self.assertIn('password1', form.fields)
|
||||
self.assertIn('password2', form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
def test_save(self):
|
||||
hostingpackage = Mock(id=42)
|
||||
instance = MagicMock(username="testuser")
|
||||
instance = MagicMock(username='testuser')
|
||||
form = ChangeMailboxPasswordForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
data={"password1": "newsecret", "password2": "newsecret"},
|
||||
)
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
data={'password1': 'newsecret', 'password2': 'newsecret'})
|
||||
self.assertTrue(form.is_valid())
|
||||
form.save(commit=False)
|
||||
instance.set_password.assert_called_with("newsecret")
|
||||
instance.set_password.assert_called_with('newsecret')
|
||||
|
||||
|
||||
class MultipleEmailValidatorTest(TestCase):
|
||||
|
||||
def test_valid_single_address(self):
|
||||
self.assertEqual(
|
||||
"test@example.org", multiple_email_validator("test@example.org")
|
||||
)
|
||||
'test@example.org',
|
||||
multiple_email_validator('test@example.org'))
|
||||
|
||||
def test_valid_multiple_addresses(self):
|
||||
self.assertEqual(
|
||||
"test1@example.org,test2@example.org",
|
||||
multiple_email_validator("test1@example.org,test2@example.org"),
|
||||
)
|
||||
'test1@example.org,test2@example.org',
|
||||
multiple_email_validator('test1@example.org,test2@example.org'))
|
||||
|
||||
def test_empty(self):
|
||||
self.assertEqual("", multiple_email_validator(""))
|
||||
self.assertEqual(
|
||||
'', multiple_email_validator(''))
|
||||
|
||||
def test_none(self):
|
||||
self.assertIsNone(multiple_email_validator(None))
|
||||
|
||||
def test_invalid_single_address(self):
|
||||
with self.assertRaises(ValidationError):
|
||||
multiple_email_validator("no@ddress")
|
||||
multiple_email_validator('no@ddress')
|
||||
|
||||
def test_invalid_multiple_addresses(self):
|
||||
with self.assertRaises(ValidationError):
|
||||
multiple_email_validator("test1@example.org,no@ddress")
|
||||
multiple_email_validator('test1@example.org,no@ddress')
|
||||
|
||||
|
||||
class MailAddressFieldMixinTest(TestCase):
|
||||
|
||||
def test_fields_defined(self):
|
||||
form = MailAddressFieldMixin()
|
||||
self.assertIn("mailbox_or_forwards", form.fields)
|
||||
self.assertIn("mailbox", form.fields)
|
||||
self.assertIn("forwards", form.fields)
|
||||
self.assertIn('mailbox_or_forwards', form.fields)
|
||||
self.assertIn('mailbox', form.fields)
|
||||
self.assertIn('forwards', form.fields)
|
||||
|
||||
|
||||
class AddMailAddressFormTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.patcher1 = patch("managemails.forms.Mailbox.objects")
|
||||
self.patcher2 = patch("managemails.forms.MailAddress.objects")
|
||||
self.patcher1 = patch('managemails.forms.Mailbox.objects')
|
||||
self.patcher2 = patch('managemails.forms.MailAddress.objects')
|
||||
self.mailbox_objects = self.patcher1.start()
|
||||
self.mailaddress_objects = self.patcher2.start()
|
||||
|
||||
|
@ -153,192 +151,175 @@ class AddMailAddressFormTest(TestCase):
|
|||
|
||||
def test_constructor(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance, hostingpackage=hostingpackage, maildomain=maildomain
|
||||
)
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain)
|
||||
self.mailbox_objects.unused.assert_called_with(osuser=osuser)
|
||||
self.assertIn("mailbox_or_forwards", form.fields)
|
||||
self.assertIn("mailbox", form.fields)
|
||||
self.assertIn("forwards", form.fields)
|
||||
self.assertTrue(hasattr(form, "hosting_package"))
|
||||
self.assertIn('mailbox_or_forwards', form.fields)
|
||||
self.assertIn('mailbox', form.fields)
|
||||
self.assertIn('forwards', form.fields)
|
||||
self.assertTrue(hasattr(form, 'hosting_package'))
|
||||
self.assertEqual(form.hosting_package, hostingpackage)
|
||||
self.assertTrue(hasattr(form, "maildomain"))
|
||||
self.assertTrue(hasattr(form, 'maildomain'))
|
||||
self.assertEqual(form.maildomain, maildomain)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_mailaddress", kwargs={"package": 42, "domain": "example.org"}),
|
||||
)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_mailaddress', kwargs={
|
||||
'package': 42, 'domain': 'example.org'}))
|
||||
self.assertEqual(len(form.helper.layout), 2)
|
||||
self.assertEqual(form.helper.layout[1].name, "submit")
|
||||
self.assertEqual(form.helper.layout[1].name, 'submit')
|
||||
|
||||
def test_clean_localpart_valid(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org'
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
self.assertEqual("test", form.clean_localpart())
|
||||
self.assertEqual('test', form.clean_localpart())
|
||||
|
||||
def test_clean_localpart_duplicate(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org'
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = True
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("localpart", form.errors)
|
||||
self.assertIn('localpart', form.errors)
|
||||
|
||||
def test_clean_no_mailbox_choice(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("mailbox", form.errors)
|
||||
self.assertIn('mailbox', form.errors)
|
||||
|
||||
def test_clean_no_forward_address_choice(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("forwards", form.errors)
|
||||
self.assertIn('forwards', form.errors)
|
||||
|
||||
def test_save_with_forwards_no_commit(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org,test3@example.org",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org,test3@example.org'
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
address1 = MagicMock(mailaddress="test2@example.org")
|
||||
address2 = MagicMock(mailaddress="test3@example.org")
|
||||
address1 = MagicMock(mailaddress='test2@example.org')
|
||||
address2 = MagicMock(mailaddress='test3@example.org')
|
||||
instance.set_forward_addresses.return_value = [address1, address2]
|
||||
form.save(commit=False)
|
||||
self.assertEqual(maildomain, instance.domain)
|
||||
instance.set_forward_addresses.assert_called_with(
|
||||
["test2@example.org", "test3@example.org"], commit=False
|
||||
)
|
||||
instance.set_forward_addresses.assert_called_with([
|
||||
'test2@example.org', 'test3@example.org'], commit=False)
|
||||
address1.save.assert_not_called()
|
||||
address2.save.assert_not_called()
|
||||
instance.save.assert_not_called()
|
||||
|
||||
def test_save_with_forwards_commit(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org,test3@example.org",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org,test3@example.org'
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
address1 = MagicMock(mailaddress="test2@example.org")
|
||||
address2 = MagicMock(mailaddress="test3@example.org")
|
||||
address1 = MagicMock(mailaddress='test2@example.org')
|
||||
address2 = MagicMock(mailaddress='test3@example.org')
|
||||
instance.set_forward_addresses.return_value = [address1, address2]
|
||||
form.save(commit=True)
|
||||
self.assertEqual(maildomain, instance.domain)
|
||||
instance.set_forward_addresses.assert_called_with(
|
||||
["test2@example.org", "test3@example.org"], commit=False
|
||||
)
|
||||
instance.set_forward_addresses.assert_called_with([
|
||||
'test2@example.org', 'test3@example.org'], commit=False)
|
||||
address1.save.assert_called_with()
|
||||
address2.save.assert_called_with()
|
||||
instance.save.assert_called_with()
|
||||
|
||||
def test_save_with_mailbox_no_commit(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
mailbox = MagicMock(osuser=osuser, username="testuserp01")
|
||||
mailbox = MagicMock(osuser=osuser, username='testuserp01')
|
||||
instance.set_mailbox.return_value = mailbox
|
||||
form.save(commit=False)
|
||||
self.assertEqual(maildomain, instance.domain)
|
||||
|
@ -348,24 +329,22 @@ class AddMailAddressFormTest(TestCase):
|
|||
|
||||
def test_save_with_mailbox_commit(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
mailbox = MagicMock(osuser=osuser, username="testuserp01")
|
||||
mailbox = MagicMock(osuser=osuser, username='testuserp01')
|
||||
instance.set_mailbox.return_value = mailbox
|
||||
form.save(commit=True)
|
||||
self.assertEqual(maildomain, instance.domain)
|
||||
|
@ -376,28 +355,26 @@ class AddMailAddressFormTest(TestCase):
|
|||
|
||||
def test_save_with_other_choice(self):
|
||||
instance = MagicMock()
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = AddMailAddressForm(
|
||||
instance=instance,
|
||||
hostingpackage=hostingpackage,
|
||||
instance=instance, hostingpackage=hostingpackage,
|
||||
maildomain=maildomain,
|
||||
data={
|
||||
"localpart": "test",
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'localpart': 'test',
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.mailaddress_objects.filter(
|
||||
domain=maildomain, localpart="test"
|
||||
domain=maildomain, localpart='test'
|
||||
).exists.return_value = False
|
||||
self.assertTrue(form.is_valid())
|
||||
form.cleaned_data["mailbox_or_forwards"] = -1
|
||||
address1 = MagicMock(mailaddress="test2@example.org")
|
||||
address2 = MagicMock(mailaddress="test3@example.org")
|
||||
form.cleaned_data['mailbox_or_forwards'] = -1
|
||||
address1 = MagicMock(mailaddress='test2@example.org')
|
||||
address2 = MagicMock(mailaddress='test3@example.org')
|
||||
instance.set_forward_addresses.return_value = [address1, address2]
|
||||
mailbox = MagicMock(osuser=osuser, username="testuserp01")
|
||||
mailbox = MagicMock(osuser=osuser, username='testuserp01')
|
||||
instance.set_mailbox.return_value = mailbox
|
||||
form.save(commit=True)
|
||||
instance.set_mailbox.assert_not_called()
|
||||
|
@ -409,9 +386,10 @@ class AddMailAddressFormTest(TestCase):
|
|||
|
||||
|
||||
class EditMailAddressFormTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.patcher1 = patch("managemails.forms.Mailbox.objects")
|
||||
self.patcher2 = patch("managemails.forms.MailAddress.objects")
|
||||
self.patcher1 = patch('managemails.forms.Mailbox.objects')
|
||||
self.patcher2 = patch('managemails.forms.MailAddress.objects')
|
||||
self.mailbox_objects = self.patcher1.start()
|
||||
self.mailaddress_objects = self.patcher2.start()
|
||||
|
||||
|
@ -431,125 +409,115 @@ class EditMailAddressFormTest(TestCase):
|
|||
|
||||
def test_constructor(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance, maildomain=maildomain, hostingpackage=hostingpackage
|
||||
)
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage)
|
||||
self.mailbox_objects.unused_or_own.assert_called_with(instance, osuser)
|
||||
self.assertIn("mailbox_or_forwards", form.fields)
|
||||
self.assertIn("mailbox", form.fields)
|
||||
self.assertIn("forwards", form.fields)
|
||||
self.assertTrue(hasattr(form, "hosting_package"))
|
||||
self.assertIn('mailbox_or_forwards', form.fields)
|
||||
self.assertIn('mailbox', form.fields)
|
||||
self.assertIn('forwards', form.fields)
|
||||
self.assertTrue(hasattr(form, 'hosting_package'))
|
||||
self.assertEqual(form.hosting_package, hostingpackage)
|
||||
self.assertTrue(hasattr(form, "maildomain"))
|
||||
self.assertTrue(hasattr(form, 'maildomain'))
|
||||
self.assertEqual(form.maildomain, maildomain)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse(
|
||||
"edit_mailaddress",
|
||||
kwargs={"package": 42, "domain": "example.org", "pk": 23},
|
||||
),
|
||||
)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'edit_mailaddress', kwargs={
|
||||
'package': 42,
|
||||
'domain': 'example.org',
|
||||
'pk': 23}))
|
||||
self.assertEqual(len(form.helper.layout), 2)
|
||||
self.assertEqual(form.helper.layout[1].name, "submit")
|
||||
self.assertEqual(form.helper.layout[1].name, 'submit')
|
||||
|
||||
def test_clean_no_mailbox_choice(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox},
|
||||
)
|
||||
data={
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
})
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("mailbox", form.errors)
|
||||
self.assertIn('mailbox', form.errors)
|
||||
|
||||
def test_clean_no_forward_address_choice(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards},
|
||||
)
|
||||
data={
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
})
|
||||
self.assertFalse(form.is_valid())
|
||||
self.assertIn("forwards", form.errors)
|
||||
self.assertIn('forwards', form.errors)
|
||||
|
||||
def test_save_with_forwards_no_commit(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org,test3@example.org",
|
||||
},
|
||||
)
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org,test3@example.org'
|
||||
})
|
||||
self.assertTrue(form.is_valid())
|
||||
address1 = MagicMock(mailaddress="test2@example.org")
|
||||
address2 = MagicMock(mailaddress="test3@example.org")
|
||||
address1 = MagicMock(mailaddress='test2@example.org')
|
||||
address2 = MagicMock(mailaddress='test3@example.org')
|
||||
instance.set_forward_addresses.return_value = [address1, address2]
|
||||
form.save(commit=False)
|
||||
instance.set_forward_addresses.assert_called_with(
|
||||
["test2@example.org", "test3@example.org"], False
|
||||
)
|
||||
['test2@example.org', 'test3@example.org'], False)
|
||||
address1.save.assert_not_called()
|
||||
address2.save.assert_not_called()
|
||||
instance.save.assert_not_called()
|
||||
|
||||
def test_save_with_forwards_commit(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.forwards,
|
||||
"forwards": "test2@example.org,test3@example.org",
|
||||
},
|
||||
)
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.forwards,
|
||||
'forwards': 'test2@example.org,test3@example.org'
|
||||
})
|
||||
self.assertTrue(form.is_valid())
|
||||
address1 = MagicMock(mailaddress="test2@example.org")
|
||||
address2 = MagicMock(mailaddress="test3@example.org")
|
||||
address1 = MagicMock(mailaddress='test2@example.org')
|
||||
address2 = MagicMock(mailaddress='test3@example.org')
|
||||
instance.set_forward_addresses.return_value = [address1, address2]
|
||||
form.save(commit=True)
|
||||
instance.set_forward_addresses.assert_called_with(
|
||||
["test2@example.org", "test3@example.org"], True
|
||||
)
|
||||
['test2@example.org', 'test3@example.org'], True)
|
||||
instance.save.assert_called_with()
|
||||
|
||||
def test_save_with_mailbox_no_commit(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.assertTrue(form.is_valid())
|
||||
mailbox = MagicMock(osuser=osuser, username="testuserp01")
|
||||
mailbox = MagicMock(osuser=osuser, username='testuserp01')
|
||||
instance.set_mailbox.return_value = mailbox
|
||||
form.save(commit=False)
|
||||
instance.set_mailbox.assert_called_with(ANY, False)
|
||||
|
@ -558,20 +526,18 @@ class EditMailAddressFormTest(TestCase):
|
|||
|
||||
def test_save_with_mailbox_commit(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.assertTrue(form.is_valid())
|
||||
mailbox = MagicMock(osuser=osuser, username="testuserp01")
|
||||
mailbox = MagicMock(osuser=osuser, username='testuserp01')
|
||||
instance.set_mailbox.return_value = mailbox
|
||||
self.mailbox_objects.unused_or_own.get.return_value = mailbox
|
||||
form.save(commit=True)
|
||||
|
@ -580,20 +546,18 @@ class EditMailAddressFormTest(TestCase):
|
|||
|
||||
def test_save_with_other_choice(self):
|
||||
instance = MagicMock(id=23)
|
||||
osuser = Mock(username="testuser")
|
||||
osuser = Mock(username='testuser')
|
||||
hostingpackage = MagicMock(id=42, osuser=osuser)
|
||||
maildomain = MagicMock(domain="example.org")
|
||||
maildomain = MagicMock(domain='example.org')
|
||||
form = EditMailAddressForm(
|
||||
instance=instance,
|
||||
maildomain=maildomain,
|
||||
instance=instance, maildomain=maildomain,
|
||||
hostingpackage=hostingpackage,
|
||||
data={
|
||||
"mailbox_or_forwards": MAILBOX_OR_FORWARDS.mailbox,
|
||||
"mailbox": "mailbox23",
|
||||
},
|
||||
)
|
||||
'mailbox_or_forwards': MAILBOX_OR_FORWARDS.mailbox,
|
||||
'mailbox': 'mailbox23',
|
||||
})
|
||||
self.assertTrue(form.is_valid())
|
||||
form.cleaned_data["mailbox_or_forwards"] = -1
|
||||
form.cleaned_data['mailbox_or_forwards'] = -1
|
||||
form.save(commit=True)
|
||||
instance.set_mailbox.assert_not_called()
|
||||
instance.save.assert_called_with()
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
"""
|
||||
This module contains tests for :py:mod:`managemails.models`
|
||||
"""
|
||||
from unittest.mock import patch
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from mock import patch
|
||||
|
||||
from django.test import TestCase, TransactionTestCase
|
||||
from django.test.utils import override_settings
|
||||
|
@ -12,51 +14,59 @@ from passlib.hash import sha512_crypt
|
|||
from domains.models import MailDomain
|
||||
from osusers.models import User
|
||||
|
||||
from managemails.models import MailAddress, Mailbox
|
||||
from managemails.models import (
|
||||
MailAddress,
|
||||
Mailbox,
|
||||
)
|
||||
|
||||
Customer = get_user_model()
|
||||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class MailboxTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(MailboxTest, self).setUp()
|
||||
self.customer = Customer.objects.create_user("test")
|
||||
self.customer = Customer.objects.create_user('test')
|
||||
|
||||
def test_set_password(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
mb = Mailbox.objects.create(username="test", osuser=user)
|
||||
mb.set_password("test")
|
||||
self.assertTrue(sha512_crypt.verify("test", mb.password))
|
||||
mb = Mailbox.objects.create(username='test', osuser=user)
|
||||
mb.set_password('test')
|
||||
self.assertTrue(sha512_crypt.verify('test', mb.password))
|
||||
|
||||
def test___str__(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
mb = Mailbox.objects.create(username="test", osuser=user)
|
||||
mb.set_password("test")
|
||||
self.assertEqual(str(mb), "test")
|
||||
mb = Mailbox.objects.create(username='test', osuser=user)
|
||||
mb.set_password('test')
|
||||
self.assertEqual(str(mb), 'test')
|
||||
|
||||
@patch("managemails.models.create_file_mailbox")
|
||||
@patch('managemails.models.create_file_mailbox')
|
||||
def test_save(self, create_file_mailbox_task):
|
||||
user = User.objects.create_user(self.customer)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
self.assertIsNotNone(mb.pk)
|
||||
create_file_mailbox_task.delay.assert_called_with(user.username, mb.username)
|
||||
create_file_mailbox_task.delay.assert_called_with(
|
||||
user.username, mb.username)
|
||||
|
||||
@patch("managemails.models.delete_file_mailbox")
|
||||
@patch('managemails.models.delete_file_mailbox')
|
||||
def test_delete(self, delete_file_mailbox_task):
|
||||
user = User.objects.create_user(self.customer)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
mb.delete()
|
||||
self.assertIsNone(mb.pk)
|
||||
delete_file_mailbox_task.delay.assert_called_with(user.username, mb.username)
|
||||
delete_file_mailbox_task.delay.assert_called_with(
|
||||
user.username, mb.username)
|
||||
|
||||
def test_get_mailaddresses(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
address.set_mailbox(mb)
|
||||
mailaddresses = mb.get_mailaddresses()
|
||||
self.assertEqual(len(mailaddresses), 1)
|
||||
|
@ -64,28 +74,31 @@ class MailboxTest(TestCase):
|
|||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class MailAddressTest(TransactionTestCase):
|
||||
|
||||
def test__str__(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
self.assertEqual(str(ma), "test@example.org")
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
self.assertEqual(str(ma), 'test@example.org')
|
||||
|
||||
def test_set_mailbox_fresh(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb)
|
||||
self.assertIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_mailbox_reassing(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb)
|
||||
mb2 = Mailbox.objects.create_mailbox(user)
|
||||
|
@ -94,178 +107,168 @@ class MailAddressTest(TransactionTestCase):
|
|||
self.assertNotIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_mailbox_with_forwards(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
ma.set_mailbox(mb)
|
||||
self.assertEqual(ma.mailaddressforward_set.count(), 0)
|
||||
self.assertIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_mailbox_with_unsaved_address(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb)
|
||||
self.assertIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_mailbox_fresh_no_commit(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb, commit=False)
|
||||
self.assertNotIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_mailbox_with_unsaved_address_no_commit(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb, commit=False)
|
||||
self.assertNotIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def test_set_forward_addresses_fresh(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
|
||||
def get_target(maf):
|
||||
return maf.target
|
||||
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
self.assertQuerysetEqual(
|
||||
ma.mailaddressforward_set.all(), ["test2@example.org"], get_target
|
||||
)
|
||||
ma.mailaddressforward_set.all(), ['test2@example.org'],
|
||||
lambda(maf): maf.target)
|
||||
|
||||
def test_set_forward_addresses_unsaved(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress(localpart="test", domain=md)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
|
||||
def get_target(maf):
|
||||
return maf.target
|
||||
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress(localpart='test', domain=md)
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
self.assertQuerysetEqual(
|
||||
ma.mailaddressforward_set.all(), ["test2@example.org"], get_target
|
||||
)
|
||||
ma.mailaddressforward_set.all(), ['test2@example.org'],
|
||||
lambda(maf): maf.target)
|
||||
|
||||
def test_set_forward_addresses_replace_forwards(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
ma.set_forward_addresses(["test3@example.org"])
|
||||
|
||||
def get_target(maf):
|
||||
return maf.target
|
||||
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
ma.set_forward_addresses(['test3@example.org'])
|
||||
self.assertQuerysetEqual(
|
||||
ma.mailaddressforward_set.all(), ["test3@example.org"], get_target
|
||||
)
|
||||
ma.mailaddressforward_set.all(), ['test3@example.org'],
|
||||
lambda(maf): maf.target)
|
||||
|
||||
def test_set_forward_addresses_add_forwards(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
ma.set_forward_addresses(["test2@example.org", "test3@example.org"])
|
||||
|
||||
def get_target(maf):
|
||||
return maf.target
|
||||
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
ma.set_forward_addresses(['test2@example.org', 'test3@example.org'])
|
||||
self.assertQuerysetEqual(
|
||||
ma.mailaddressforward_set.all(),
|
||||
["test2@example.org", "test3@example.org"],
|
||||
get_target,
|
||||
ordered=False,
|
||||
)
|
||||
['test2@example.org', 'test3@example.org'],
|
||||
lambda(maf): maf.target,
|
||||
ordered=False)
|
||||
|
||||
def test_set_forward_addresses_replace_mailbox(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb)
|
||||
ma.set_forward_addresses(["test2@example.org"])
|
||||
ma.set_forward_addresses(['test2@example.org'])
|
||||
self.assertNotIn(ma, mb.get_mailaddresses())
|
||||
|
||||
def get_target(maf):
|
||||
return maf.target
|
||||
|
||||
self.assertQuerysetEqual(
|
||||
ma.mailaddressforward_set.all(), ["test2@example.org"], get_target
|
||||
)
|
||||
ma.mailaddressforward_set.all(), ['test2@example.org'],
|
||||
lambda(maf): maf.target)
|
||||
|
||||
def test_set_forward_addresses_fresh_no_commit(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress.objects.create(localpart="test", domain=md)
|
||||
mafwds = ma.set_forward_addresses(["test2@example.org"], commit=False)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mafwds = ma.set_forward_addresses(['test2@example.org'], commit=False)
|
||||
self.assertEqual(ma.mailaddressforward_set.count(), 0)
|
||||
self.assertEqual(mafwds[0].target, "test2@example.org")
|
||||
self.assertEqual(mafwds[0].target, 'test2@example.org')
|
||||
|
||||
def test_set_forward_address_unsaved_no_commit(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress(localpart="test", domain=md)
|
||||
mafwds = ma.set_forward_addresses(["test2@example.org"], commit=False)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress(localpart='test', domain=md)
|
||||
mafwds = ma.set_forward_addresses(['test2@example.org'], commit=False)
|
||||
self.assertEqual(ma.mailaddressforward_set.count(), 0)
|
||||
self.assertEqual(mafwds[0].target, "test2@example.org")
|
||||
self.assertEqual(mafwds[0].target, 'test2@example.org')
|
||||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class MailboxManagerTest(TransactionTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(MailboxManagerTest, self).setUp()
|
||||
self.customer = Customer.objects.create_user("test")
|
||||
self.customer = Customer.objects.create_user('test')
|
||||
self.user = User.objects.create_user(self.customer)
|
||||
|
||||
def test_get_next_mailbox_name_fresh(self):
|
||||
mailboxname = Mailbox.objects.get_next_mailbox_name(self.user)
|
||||
self.assertEqual(mailboxname, "{}p01".format(self.user.username))
|
||||
self.assertEqual(mailboxname, '{}p01'.format(self.user.username))
|
||||
|
||||
def test_get_next_mailbox_name_second(self):
|
||||
Mailbox.objects.create_mailbox(self.user)
|
||||
mailboxname = Mailbox.objects.get_next_mailbox_name(self.user)
|
||||
self.assertEqual(mailboxname, "{}p02".format(self.user.username))
|
||||
self.assertEqual(mailboxname, '{}p02'.format(self.user.username))
|
||||
|
||||
def test_get_next_mailbox_name_gap_detection(self):
|
||||
mailboxes = [Mailbox.objects.create_mailbox(self.user) for _ in range(3)]
|
||||
mailboxes = [
|
||||
Mailbox.objects.create_mailbox(self.user) for i in range(3)
|
||||
]
|
||||
mailboxes[1].delete()
|
||||
mailboxname = Mailbox.objects.get_next_mailbox_name(self.user)
|
||||
self.assertEqual(mailboxname, "{}p02".format(self.user.username))
|
||||
self.assertEqual(mailboxname, '{}p02'.format(self.user.username))
|
||||
|
||||
def test_unused_or_own_fresh(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mailboxes = Mailbox.objects.unused_or_own(address, self.user)
|
||||
self.assertQuerysetEqual(mailboxes, [])
|
||||
|
||||
def test_unused_or_own_unassigned(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
mailboxes = [Mailbox.objects.create_mailbox(self.user) for _ in range(2)]
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mailboxes = [
|
||||
Mailbox.objects.create_mailbox(self.user) for i in range(2)
|
||||
]
|
||||
assignable = Mailbox.objects.unused_or_own(address, self.user)
|
||||
self.assertQuerysetEqual(assignable, [repr(mb) for mb in mailboxes])
|
||||
|
||||
def test_unused_or_own_assigned(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
mailboxes = [Mailbox.objects.create_mailbox(self.user) for _ in range(2)]
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mailboxes = [
|
||||
Mailbox.objects.create_mailbox(self.user) for i in range(2)
|
||||
]
|
||||
address.set_mailbox(mailboxes[0])
|
||||
assignable = Mailbox.objects.unused_or_own(address, self.user)
|
||||
self.assertQuerysetEqual(assignable, [repr(mb) for mb in mailboxes])
|
||||
|
||||
def test_unused_or_own_assigned_other(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
address2 = MailAddress.objects.create(localpart="test2", domain=md)
|
||||
mailboxes = [Mailbox.objects.create_mailbox(self.user) for _ in range(2)]
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
address2 = MailAddress.objects.create(localpart='test2', domain=md)
|
||||
mailboxes = [
|
||||
Mailbox.objects.create_mailbox(self.user) for i in range(2)
|
||||
]
|
||||
address2.set_mailbox(mailboxes[0])
|
||||
assignable = Mailbox.objects.unused_or_own(address, self.user)
|
||||
self.assertQuerysetEqual(assignable, [repr(mailboxes[1])])
|
||||
|
@ -280,9 +283,11 @@ class MailboxManagerTest(TransactionTestCase):
|
|||
self.assertQuerysetEqual(mailboxes, [repr(mailbox)])
|
||||
|
||||
def test_unused_assigned(self):
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
address = MailAddress.objects.create(localpart="test", domain=md)
|
||||
mailboxes = [Mailbox.objects.create_mailbox(self.user) for _ in range(2)]
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
address = MailAddress.objects.create(localpart='test', domain=md)
|
||||
mailboxes = [
|
||||
Mailbox.objects.create_mailbox(self.user) for i in range(2)
|
||||
]
|
||||
address.set_mailbox(mailboxes[0])
|
||||
assignable = Mailbox.objects.unused(self.user)
|
||||
self.assertQuerysetEqual(assignable, [repr(mailboxes[1])])
|
||||
|
@ -290,28 +295,31 @@ class MailboxManagerTest(TransactionTestCase):
|
|||
def test_create_mailbox_no_password(self):
|
||||
mailbox = Mailbox.objects.create_mailbox(self.user)
|
||||
self.assertEqual(mailbox.osuser, self.user)
|
||||
self.assertEqual(mailbox.username, "{}p01".format(self.user.username))
|
||||
self.assertEqual(mailbox.password, "")
|
||||
self.assertEqual(mailbox.username, '{}p01'.format(self.user.username))
|
||||
self.assertEqual(mailbox.password, '')
|
||||
|
||||
def test_create_mailbox_with_password(self):
|
||||
mailbox = Mailbox.objects.create_mailbox(self.user, "test")
|
||||
mailbox = Mailbox.objects.create_mailbox(self.user, 'test')
|
||||
self.assertEqual(mailbox.osuser, self.user)
|
||||
self.assertEqual(mailbox.username, "{}p01".format(self.user.username))
|
||||
self.assertTrue(sha512_crypt.verify("test", mailbox.password))
|
||||
self.assertEqual(mailbox.username, '{}p01'.format(self.user.username))
|
||||
self.assertTrue(sha512_crypt.verify('test', mailbox.password))
|
||||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class MailAddressMailboxTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(MailAddressMailboxTest, self).setUp()
|
||||
self.customer = Customer.objects.create_user("test")
|
||||
self.customer = Customer.objects.create_user('test')
|
||||
|
||||
def test___str__(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
md = MailDomain.objects.create(domain="example.org")
|
||||
ma = MailAddress(localpart="test", domain=md)
|
||||
md = MailDomain.objects.create(domain='example.org')
|
||||
ma = MailAddress(localpart='test', domain=md)
|
||||
mb = Mailbox.objects.create_mailbox(user)
|
||||
ma.set_mailbox(mb)
|
||||
self.assertEqual(str(ma.mailaddressmailbox), mb.username)
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -7,14 +7,26 @@ The module starts Celery_ tasks.
|
|||
|
||||
"""
|
||||
from django import forms
|
||||
from django.contrib import admin
|
||||
from django.utils.translation import ugettext_lazy as _
|
||||
from django.contrib import admin
|
||||
|
||||
from fileservertasks.tasks import set_file_ssh_authorized_keys
|
||||
from gvawebcore.forms import PASSWORD_MISMATCH_ERROR
|
||||
from gvawebcore.forms import (
|
||||
PASSWORD_MISMATCH_ERROR
|
||||
)
|
||||
from taskresults.models import TaskResult
|
||||
from .forms import DUPLICATE_SSH_PUBLIC_KEY_FOR_USER, INVALID_SSH_PUBLIC_KEY
|
||||
from .models import AdditionalGroup, Group, Shadow, SshPublicKey, User
|
||||
|
||||
from .forms import (
|
||||
INVALID_SSH_PUBLIC_KEY,
|
||||
DUPLICATE_SSH_PUBLIC_KEY_FOR_USER,
|
||||
)
|
||||
from .models import (
|
||||
AdditionalGroup,
|
||||
Group,
|
||||
Shadow,
|
||||
SshPublicKey,
|
||||
User,
|
||||
)
|
||||
|
||||
|
||||
class AdditionalGroupInline(admin.TabularInline):
|
||||
|
@ -22,7 +34,6 @@ class AdditionalGroupInline(admin.TabularInline):
|
|||
Inline for :py:class:`osusers.models.AdditionalGroup` instances.
|
||||
|
||||
"""
|
||||
|
||||
model = AdditionalGroup
|
||||
|
||||
|
||||
|
@ -31,9 +42,8 @@ class ShadowInline(admin.TabularInline):
|
|||
Inline for :py:class:`osusers.models.ShadowInline` instances.
|
||||
|
||||
"""
|
||||
|
||||
model = Shadow
|
||||
readonly_fields = ["passwd"]
|
||||
readonly_fields = ['passwd']
|
||||
can_delete = False
|
||||
|
||||
|
||||
|
@ -43,17 +53,18 @@ class UserCreationForm(forms.ModelForm):
|
|||
<osusers.models.User>`.
|
||||
|
||||
"""
|
||||
|
||||
password1 = forms.CharField(
|
||||
label=_("Password"), widget=forms.PasswordInput, required=False
|
||||
label=_('Password'), widget=forms.PasswordInput,
|
||||
required=False,
|
||||
)
|
||||
password2 = forms.CharField(
|
||||
label=_("Password (again)"), widget=forms.PasswordInput, required=False
|
||||
label=_('Password (again)'), widget=forms.PasswordInput,
|
||||
required=False,
|
||||
)
|
||||
|
||||
class Meta:
|
||||
model = User
|
||||
fields = ["customer"]
|
||||
fields = ['customer']
|
||||
|
||||
def clean_password2(self):
|
||||
"""
|
||||
|
@ -63,8 +74,8 @@ class UserCreationForm(forms.ModelForm):
|
|||
:rtype: str or None
|
||||
|
||||
"""
|
||||
password1 = self.cleaned_data.get("password1")
|
||||
password2 = self.cleaned_data.get("password2")
|
||||
password1 = self.cleaned_data.get('password1')
|
||||
password2 = self.cleaned_data.get('password2')
|
||||
if password1 and password2 and password1 != password2:
|
||||
raise forms.ValidationError(PASSWORD_MISMATCH_ERROR)
|
||||
return password2
|
||||
|
@ -79,10 +90,8 @@ class UserCreationForm(forms.ModelForm):
|
|||
|
||||
"""
|
||||
user = User.objects.create_user(
|
||||
customer=self.cleaned_data["customer"],
|
||||
password=self.cleaned_data["password1"],
|
||||
commit=commit,
|
||||
)
|
||||
customer=self.cleaned_data['customer'],
|
||||
password=self.cleaned_data['password1'], commit=commit)
|
||||
return user
|
||||
|
||||
def save_m2m(self):
|
||||
|
@ -99,16 +108,14 @@ class UserAdmin(admin.ModelAdmin):
|
|||
<osusers.models.User>`.
|
||||
|
||||
"""
|
||||
|
||||
actions = ["perform_delete_selected"]
|
||||
actions = ['perform_delete_selected']
|
||||
add_form = UserCreationForm
|
||||
inlines = [AdditionalGroupInline, ShadowInline]
|
||||
|
||||
add_fieldsets = (
|
||||
(
|
||||
None,
|
||||
{"classes": ("wide",), "fields": ("customer", "password1", "password2")},
|
||||
),
|
||||
(None, {
|
||||
'classes': ('wide',),
|
||||
'fields': ('customer', 'password1', 'password2')}),
|
||||
)
|
||||
|
||||
def get_form(self, request, obj=None, **kwargs):
|
||||
|
@ -125,12 +132,10 @@ class UserAdmin(admin.ModelAdmin):
|
|||
"""
|
||||
defaults = {}
|
||||
if obj is None:
|
||||
defaults.update(
|
||||
{
|
||||
"form": self.add_form,
|
||||
"fields": admin.options.flatten_fieldsets(self.add_fieldsets),
|
||||
}
|
||||
)
|
||||
defaults.update({
|
||||
'form': self.add_form,
|
||||
'fields': admin.options.flatten_fieldsets(self.add_fieldsets),
|
||||
})
|
||||
defaults.update(kwargs)
|
||||
return super(UserAdmin, self).get_form(request, obj, **defaults)
|
||||
|
||||
|
@ -146,7 +151,7 @@ class UserAdmin(admin.ModelAdmin):
|
|||
|
||||
"""
|
||||
if obj:
|
||||
return ["uid"]
|
||||
return ['uid']
|
||||
return []
|
||||
|
||||
def perform_delete_selected(self, request, queryset):
|
||||
|
@ -162,8 +167,7 @@ class UserAdmin(admin.ModelAdmin):
|
|||
"""
|
||||
for user in queryset.all():
|
||||
user.delete()
|
||||
|
||||
perform_delete_selected.short_description = _("Delete selected users")
|
||||
perform_delete_selected.short_description = _('Delete selected users')
|
||||
|
||||
def get_actions(self, request):
|
||||
"""
|
||||
|
@ -178,8 +182,8 @@ class UserAdmin(admin.ModelAdmin):
|
|||
|
||||
"""
|
||||
actions = super(UserAdmin, self).get_actions(request)
|
||||
if "delete_selected" in actions: # pragma: no cover
|
||||
del actions["delete_selected"]
|
||||
if 'delete_selected' in actions: # pragma: no cover
|
||||
del actions['delete_selected']
|
||||
return actions
|
||||
|
||||
|
||||
|
@ -189,8 +193,7 @@ class GroupAdmin(admin.ModelAdmin):
|
|||
<osusers.models.Group>`.
|
||||
|
||||
"""
|
||||
|
||||
actions = ["perform_delete_selected"]
|
||||
actions = ['perform_delete_selected']
|
||||
|
||||
def perform_delete_selected(self, request, queryset):
|
||||
"""
|
||||
|
@ -205,8 +208,7 @@ class GroupAdmin(admin.ModelAdmin):
|
|||
"""
|
||||
for group in queryset.all():
|
||||
group.delete()
|
||||
|
||||
perform_delete_selected.short_description = _("Delete selected groups")
|
||||
perform_delete_selected.short_description = _('Delete selected groups')
|
||||
|
||||
def get_actions(self, request):
|
||||
"""
|
||||
|
@ -221,8 +223,8 @@ class GroupAdmin(admin.ModelAdmin):
|
|||
|
||||
"""
|
||||
actions = super(GroupAdmin, self).get_actions(request)
|
||||
if "delete_selected" in actions: # pragma: no cover
|
||||
del actions["delete_selected"]
|
||||
if 'delete_selected' in actions: # pragma: no cover
|
||||
del actions['delete_selected']
|
||||
return actions
|
||||
|
||||
|
||||
|
@ -232,37 +234,33 @@ class SshPublicKeyCreationForm(forms.ModelForm):
|
|||
<osusers.models.SshPublicKey>`.
|
||||
|
||||
"""
|
||||
|
||||
publickeytext = forms.CharField(
|
||||
label=_("Key text"),
|
||||
widget=forms.Textarea,
|
||||
help_text=_("A SSH public key in either OpenSSH or RFC 4716 format"),
|
||||
)
|
||||
label=_('Key text'), widget=forms.Textarea,
|
||||
help_text=_('A SSH public key in either OpenSSH or RFC 4716 format'))
|
||||
|
||||
class Meta:
|
||||
model = SshPublicKey
|
||||
fields = ["user"]
|
||||
fields = ['user']
|
||||
|
||||
def clean_publickeytext(self):
|
||||
keytext = self.cleaned_data.get("publickeytext")
|
||||
keytext = self.cleaned_data.get('publickeytext')
|
||||
try:
|
||||
SshPublicKey.objects.parse_key_text(keytext)
|
||||
SshPublicKey.objects.parse_keytext(keytext)
|
||||
except:
|
||||
raise forms.ValidationError(INVALID_SSH_PUBLIC_KEY)
|
||||
return keytext
|
||||
|
||||
def clean(self):
|
||||
user = self.cleaned_data.get("user")
|
||||
keytext = self.cleaned_data.get("publickeytext")
|
||||
user = self.cleaned_data.get('user')
|
||||
keytext = self.cleaned_data.get('publickeytext')
|
||||
if user and keytext:
|
||||
alg, data, comment = SshPublicKey.objects.parse_key_text(keytext)
|
||||
alg, data, comment = SshPublicKey.objects.parse_keytext(keytext)
|
||||
if SshPublicKey.objects.filter(
|
||||
user=user, algorithm=alg, data=data
|
||||
).exists():
|
||||
self.add_error(
|
||||
"publickeytext",
|
||||
forms.ValidationError(DUPLICATE_SSH_PUBLIC_KEY_FOR_USER),
|
||||
)
|
||||
'publickeytext',
|
||||
forms.ValidationError(DUPLICATE_SSH_PUBLIC_KEY_FOR_USER))
|
||||
super(SshPublicKeyCreationForm, self).clean()
|
||||
|
||||
def save(self, commit=True):
|
||||
|
@ -274,9 +272,8 @@ class SshPublicKeyCreationForm(forms.ModelForm):
|
|||
:rtype: :py:class:`osusers.models.SshPublicKey`
|
||||
|
||||
"""
|
||||
algorithm, keydata, comment = SshPublicKey.objects.parse_key_text(
|
||||
self.cleaned_data.get("publickeytext")
|
||||
)
|
||||
algorithm, keydata, comment = SshPublicKey.objects.parse_keytext(
|
||||
self.cleaned_data.get('publickeytext'))
|
||||
self.instance.algorithm = algorithm
|
||||
self.instance.data = keydata
|
||||
self.instance.comment = comment
|
||||
|
@ -289,13 +286,14 @@ class SshPublicKeyAdmin(admin.ModelAdmin):
|
|||
<osusers.models.SshPublicKey>`.
|
||||
|
||||
"""
|
||||
|
||||
actions = ["perform_delete_selected"]
|
||||
actions = ['perform_delete_selected']
|
||||
add_form = SshPublicKeyCreationForm
|
||||
list_display = ["user", "algorithm", "comment"]
|
||||
list_display = ['user', 'algorithm', 'comment']
|
||||
|
||||
add_fieldsets = (
|
||||
(None, {"classes": ("wide",), "fields": ("user", "publickeytext")}),
|
||||
(None, {
|
||||
'classes': ('wide',),
|
||||
'fields': ('user', 'publickeytext')}),
|
||||
)
|
||||
|
||||
def get_form(self, request, obj=None, **kwargs):
|
||||
|
@ -313,14 +311,13 @@ class SshPublicKeyAdmin(admin.ModelAdmin):
|
|||
"""
|
||||
defaults = {}
|
||||
if obj is None:
|
||||
defaults.update(
|
||||
{
|
||||
"form": self.add_form,
|
||||
"fields": admin.options.flatten_fieldsets(self.add_fieldsets),
|
||||
}
|
||||
)
|
||||
defaults.update({
|
||||
'form': self.add_form,
|
||||
'fields': admin.options.flatten_fieldsets(self.add_fieldsets),
|
||||
})
|
||||
defaults.update(kwargs)
|
||||
return super(SshPublicKeyAdmin, self).get_form(request, obj, **defaults)
|
||||
return super(SshPublicKeyAdmin, self).get_form(
|
||||
request, obj, **defaults)
|
||||
|
||||
def get_readonly_fields(self, request, obj=None):
|
||||
"""
|
||||
|
@ -335,7 +332,7 @@ class SshPublicKeyAdmin(admin.ModelAdmin):
|
|||
|
||||
"""
|
||||
if obj:
|
||||
return ["algorithm", "data"]
|
||||
return ['algorithm', 'data']
|
||||
return []
|
||||
|
||||
def perform_delete_selected(self, request, queryset):
|
||||
|
@ -373,19 +370,23 @@ class SshPublicKeyAdmin(admin.ModelAdmin):
|
|||
}
|
||||
|
||||
"""
|
||||
users = set([item["user"] for item in queryset.values("user").distinct()])
|
||||
users = set([
|
||||
item['user'] for item in
|
||||
queryset.values('user').distinct()
|
||||
])
|
||||
queryset.delete()
|
||||
for user in users:
|
||||
# TODO: move to model/signal
|
||||
TaskResult.objects.create_task_result(
|
||||
"perform_delete_selected",
|
||||
'perform_delete_selected',
|
||||
set_file_ssh_authorized_keys.s(
|
||||
User.objects.get(uid=user).username,
|
||||
[str(key) for key in SshPublicKey.objects.filter(user_id=user)],
|
||||
),
|
||||
[str(key) for key in SshPublicKey.objects.filter(
|
||||
user_id=user)]
|
||||
)
|
||||
)
|
||||
|
||||
perform_delete_selected.short_description = _("Delete selected SSH public keys")
|
||||
perform_delete_selected.short_description = _(
|
||||
'Delete selected SSH public keys')
|
||||
|
||||
def get_actions(self, request):
|
||||
"""
|
||||
|
@ -400,8 +401,8 @@ class SshPublicKeyAdmin(admin.ModelAdmin):
|
|||
|
||||
"""
|
||||
actions = super(SshPublicKeyAdmin, self).get_actions(request)
|
||||
if "delete_selected" in actions: # pragma: no cover
|
||||
del actions["delete_selected"]
|
||||
if 'delete_selected' in actions: # pragma: no cover
|
||||
del actions['delete_selected']
|
||||
return actions
|
||||
|
||||
|
||||
|
|
|
@ -13,20 +13,21 @@ from crispy_forms.layout import Submit
|
|||
|
||||
from gvawebcore.forms import PasswordModelFormMixin
|
||||
|
||||
from .models import SshPublicKey, User
|
||||
|
||||
INVALID_SSH_PUBLIC_KEY = _("Invalid SSH public key data format.")
|
||||
DUPLICATE_SSH_PUBLIC_KEY_FOR_USER = _(
|
||||
"This SSH public key is already assigned to this user."
|
||||
from .models import (
|
||||
SshPublicKey,
|
||||
User,
|
||||
)
|
||||
|
||||
INVALID_SSH_PUBLIC_KEY = _('Invalid SSH public key data format.')
|
||||
DUPLICATE_SSH_PUBLIC_KEY_FOR_USER = _(
|
||||
'This SSH public key is already assigned to this user.')
|
||||
|
||||
|
||||
class ChangeOsUserPasswordForm(PasswordModelFormMixin, forms.ModelForm):
|
||||
"""
|
||||
A form for setting an OS user's password.
|
||||
|
||||
"""
|
||||
|
||||
class Meta:
|
||||
model = User
|
||||
fields = []
|
||||
|
@ -35,9 +36,8 @@ class ChangeOsUserPasswordForm(PasswordModelFormMixin, forms.ModelForm):
|
|||
self.helper = FormHelper()
|
||||
super(ChangeOsUserPasswordForm, self).__init__(*args, **kwargs)
|
||||
self.helper.form_action = reverse(
|
||||
"set_osuser_password", kwargs={"slug": self.instance.username}
|
||||
)
|
||||
self.helper.add_input(Submit("submit", _("Set password")))
|
||||
'set_osuser_password', kwargs={'slug': self.instance.username})
|
||||
self.helper.add_input(Submit('submit', _('Set password')))
|
||||
|
||||
def save(self, commit=True):
|
||||
"""
|
||||
|
@ -48,7 +48,7 @@ class ChangeOsUserPasswordForm(PasswordModelFormMixin, forms.ModelForm):
|
|||
:rtype: :py:class:`osusers.models.User`
|
||||
|
||||
"""
|
||||
self.instance.set_password(self.cleaned_data["password1"])
|
||||
self.instance.set_password(self.cleaned_data['password1'])
|
||||
return super(ChangeOsUserPasswordForm, self).save(commit=commit)
|
||||
|
||||
|
||||
|
@ -58,45 +58,41 @@ class AddSshPublicKeyForm(forms.ModelForm):
|
|||
<osusers.models.SshPublicKey>`.
|
||||
|
||||
"""
|
||||
|
||||
publickeytext = forms.CharField(
|
||||
label=_("Key text"),
|
||||
widget=forms.Textarea,
|
||||
help_text=_("A SSH public key in either OpenSSH or RFC 4716 format"),
|
||||
)
|
||||
label=_('Key text'), widget=forms.Textarea,
|
||||
help_text=_('A SSH public key in either OpenSSH or RFC 4716 format'))
|
||||
|
||||
class Meta:
|
||||
model = SshPublicKey
|
||||
fields = []
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
hosting_package = kwargs.pop("hostingpackage")
|
||||
hosting_package = kwargs.pop('hostingpackage')
|
||||
self.osuser = hosting_package.osuser
|
||||
super(AddSshPublicKeyForm, self).__init__(*args, **kwargs)
|
||||
self.helper = FormHelper()
|
||||
self.helper.form_action = reverse(
|
||||
"add_ssh_key", kwargs={"package": hosting_package.id}
|
||||
)
|
||||
self.helper.add_input(Submit("submit", _("Add SSH public key")))
|
||||
'add_ssh_key', kwargs={'package': hosting_package.id})
|
||||
self.helper.add_input(Submit('submit', _('Add SSH public key')))
|
||||
|
||||
def clean_publickeytext(self):
|
||||
keytext = self.cleaned_data.get("publickeytext")
|
||||
keytext = self.cleaned_data.get('publickeytext')
|
||||
try:
|
||||
SshPublicKey.objects.parse_key_text(keytext)
|
||||
SshPublicKey.objects.parse_keytext(keytext)
|
||||
except ValueError:
|
||||
raise forms.ValidationError(INVALID_SSH_PUBLIC_KEY)
|
||||
return keytext
|
||||
|
||||
def clean(self):
|
||||
keytext = self.cleaned_data.get("publickeytext")
|
||||
keytext = self.cleaned_data.get('publickeytext')
|
||||
if keytext is not None:
|
||||
alg, data, comment = SshPublicKey.objects.parse_key_text(keytext)
|
||||
alg, data, comment = SshPublicKey.objects.parse_keytext(keytext)
|
||||
if SshPublicKey.objects.filter(
|
||||
user=self.osuser, algorithm=alg, data=data
|
||||
).exists():
|
||||
self.add_error(
|
||||
"publickeytext",
|
||||
forms.ValidationError(DUPLICATE_SSH_PUBLIC_KEY_FOR_USER),
|
||||
'publickeytext',
|
||||
forms.ValidationError(DUPLICATE_SSH_PUBLIC_KEY_FOR_USER)
|
||||
)
|
||||
|
||||
def save(self, commit=True):
|
||||
|
@ -108,9 +104,8 @@ class AddSshPublicKeyForm(forms.ModelForm):
|
|||
:rtype: :py:class:`osusers.models.SshPublicKey`
|
||||
|
||||
"""
|
||||
algorithm, keydata, comment = SshPublicKey.objects.parse_key_text(
|
||||
self.cleaned_data.get("publickeytext")
|
||||
)
|
||||
algorithm, keydata, comment = SshPublicKey.objects.parse_keytext(
|
||||
self.cleaned_data.get('publickeytext'))
|
||||
self.instance.user = self.osuser
|
||||
self.instance.algorithm = algorithm
|
||||
self.instance.data = keydata
|
||||
|
@ -124,19 +119,17 @@ class EditSshPublicKeyCommentForm(forms.ModelForm):
|
|||
<osusers.models.SshPublicKey>` comment fields.
|
||||
|
||||
"""
|
||||
|
||||
class Meta:
|
||||
model = SshPublicKey
|
||||
fields = ["comment"]
|
||||
fields = ['comment']
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
hosting_package = kwargs.pop("hostingpackage")
|
||||
hosting_package = kwargs.pop('hostingpackage')
|
||||
self.osuser = hosting_package.osuser
|
||||
super(EditSshPublicKeyCommentForm, self).__init__(*args, **kwargs)
|
||||
self.fields["comment"].widget = forms.TextInput()
|
||||
self.fields['comment'].widget = forms.TextInput()
|
||||
self.helper = FormHelper()
|
||||
self.helper.form_action = reverse(
|
||||
"edit_ssh_key_comment",
|
||||
kwargs={"package": hosting_package.id, "pk": self.instance.id},
|
||||
)
|
||||
self.helper.add_input(Submit("submit", _("Change Comment")))
|
||||
'edit_ssh_key_comment',
|
||||
kwargs={'package': hosting_package.id, 'pk': self.instance.id})
|
||||
self.helper.add_input(Submit('submit', _('Change Comment')))
|
||||
|
|
|
@ -2,16 +2,20 @@
|
|||
This module defines the database models of operating system users.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import base64
|
||||
from datetime import date
|
||||
import logging
|
||||
import os
|
||||
import six
|
||||
|
||||
from django.db import models, transaction
|
||||
from django.conf import settings
|
||||
from django.core.exceptions import ValidationError
|
||||
from django.dispatch import Signal
|
||||
from django.utils import timezone
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
from django.utils.translation import ugettext as _
|
||||
|
||||
from model_utils.models import TimeStampedModel
|
||||
|
@ -23,10 +27,11 @@ from passlib.utils import generate_password
|
|||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
|
||||
password_set = Signal(providing_args=["instance", "password"])
|
||||
password_set = Signal(providing_args=['instance', 'password'])
|
||||
|
||||
|
||||
CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL = _("You can not use a user's primary group.")
|
||||
CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL = _(
|
||||
"You can not use a user's primary group.")
|
||||
|
||||
|
||||
class GroupManager(models.Manager):
|
||||
|
@ -43,31 +48,34 @@ class GroupManager(models.Manager):
|
|||
:rtype: int
|
||||
|
||||
"""
|
||||
q = self.aggregate(models.Max("gid"))
|
||||
if q["gid__max"] is None:
|
||||
q = self.aggregate(models.Max('gid'))
|
||||
if q['gid__max'] is None:
|
||||
return settings.OSUSER_MINGID
|
||||
return max(settings.OSUSER_MINGID, q["gid__max"] + 1)
|
||||
return max(settings.OSUSER_MINGID, q['gid__max'] + 1)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Group(TimeStampedModel, models.Model):
|
||||
"""
|
||||
This entity class corresponds to an operating system group.
|
||||
|
||||
"""
|
||||
|
||||
groupname = models.CharField(_("Group name"), max_length=16, unique=True)
|
||||
gid = models.PositiveSmallIntegerField(_("Group ID"), unique=True, primary_key=True)
|
||||
descr = models.TextField(_("Description"), blank=True)
|
||||
passwd = models.CharField(_("Group password"), max_length=128, blank=True)
|
||||
groupname = models.CharField(
|
||||
_('Group name'), max_length=16, unique=True)
|
||||
gid = models.PositiveSmallIntegerField(
|
||||
_('Group ID'), unique=True, primary_key=True)
|
||||
descr = models.TextField(_('Description'), blank=True)
|
||||
passwd = models.CharField(
|
||||
_('Group password'), max_length=128, blank=True)
|
||||
|
||||
objects = GroupManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("Group")
|
||||
verbose_name_plural = _("Groups")
|
||||
verbose_name = _('Group')
|
||||
verbose_name_plural = _('Groups')
|
||||
|
||||
def __str__(self):
|
||||
return "{0} ({1})".format(self.groupname, self.gid)
|
||||
return '{0} ({1})'.format(self.groupname, self.gid)
|
||||
|
||||
@transaction.atomic
|
||||
def save(self, *args, **kwargs):
|
||||
|
@ -114,10 +122,10 @@ class UserManager(models.Manager):
|
|||
:rtype: int
|
||||
|
||||
"""
|
||||
q = self.aggregate(models.Max("uid"))
|
||||
if q["uid__max"] is None:
|
||||
q = self.aggregate(models.Max('uid'))
|
||||
if q['uid__max'] is None:
|
||||
return settings.OSUSER_MINUID
|
||||
return max(settings.OSUSER_MINUID, q["uid__max"] + 1)
|
||||
return max(settings.OSUSER_MINUID, q['uid__max'] + 1)
|
||||
|
||||
def get_next_username(self):
|
||||
"""
|
||||
|
@ -129,21 +137,23 @@ class UserManager(models.Manager):
|
|||
"""
|
||||
count = 1
|
||||
usernameformat = "{0}{1:02d}"
|
||||
nextuser = usernameformat.format(settings.OSUSER_USERNAME_PREFIX, count)
|
||||
for user in (
|
||||
self.values("username")
|
||||
.filter(username__startswith=settings.OSUSER_USERNAME_PREFIX)
|
||||
.order_by("username")
|
||||
):
|
||||
if user["username"] == nextuser:
|
||||
nextuser = usernameformat.format(settings.OSUSER_USERNAME_PREFIX,
|
||||
count)
|
||||
for user in self.values('username').filter(
|
||||
username__startswith=settings.OSUSER_USERNAME_PREFIX
|
||||
).order_by('username'):
|
||||
if user['username'] == nextuser:
|
||||
count += 1
|
||||
nextuser = usernameformat.format(settings.OSUSER_USERNAME_PREFIX, count)
|
||||
nextuser = usernameformat.format(
|
||||
settings.OSUSER_USERNAME_PREFIX, count)
|
||||
else:
|
||||
break
|
||||
return nextuser
|
||||
|
||||
@transaction.atomic
|
||||
def create_user(self, customer, username=None, password=None, commit=False):
|
||||
def create_user(
|
||||
self, customer, username=None, password=None, commit=False
|
||||
):
|
||||
"""
|
||||
Create a new user with a primary group named the same as the user and
|
||||
an initial password.
|
||||
|
@ -169,42 +179,41 @@ class UserManager(models.Manager):
|
|||
password = generate_password()
|
||||
homedir = os.path.join(settings.OSUSER_HOME_BASEPATH, username)
|
||||
group = Group.objects.create(groupname=username, gid=gid)
|
||||
user = self.create(
|
||||
username=username,
|
||||
group=group,
|
||||
uid=uid,
|
||||
homedir=homedir,
|
||||
customer=customer,
|
||||
shell=settings.OSUSER_DEFAULT_SHELL,
|
||||
)
|
||||
user = self.create(username=username, group=group, uid=uid,
|
||||
homedir=homedir, customer=customer,
|
||||
shell=settings.OSUSER_DEFAULT_SHELL)
|
||||
user.set_password(password)
|
||||
if commit:
|
||||
user.save()
|
||||
return user
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class User(TimeStampedModel, models.Model):
|
||||
"""
|
||||
This entity class corresponds to an operating system user.
|
||||
|
||||
"""
|
||||
|
||||
username = models.CharField(_("User name"), max_length=64, unique=True)
|
||||
uid = models.PositiveSmallIntegerField(_("User ID"), unique=True, primary_key=True)
|
||||
group = models.ForeignKey(Group, verbose_name=_("Group"), on_delete=models.CASCADE)
|
||||
gecos = models.CharField(_("Gecos field"), max_length=128, blank=True)
|
||||
homedir = models.CharField(_("Home directory"), max_length=256)
|
||||
shell = models.CharField(_("Login shell"), max_length=64)
|
||||
customer = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
|
||||
username = models.CharField(
|
||||
_('User name'), max_length=64, unique=True)
|
||||
uid = models.PositiveSmallIntegerField(
|
||||
_('User ID'), unique=True, primary_key=True)
|
||||
group = models.ForeignKey(
|
||||
Group, verbose_name=_('Group'), on_delete=models.CASCADE)
|
||||
gecos = models.CharField(_('Gecos field'), max_length=128, blank=True)
|
||||
homedir = models.CharField(_('Home directory'), max_length=256)
|
||||
shell = models.CharField(_('Login shell'), max_length=64)
|
||||
customer = models.ForeignKey(
|
||||
settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
|
||||
|
||||
objects = UserManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("User")
|
||||
verbose_name_plural = _("Users")
|
||||
verbose_name = _('User')
|
||||
verbose_name_plural = _('Users')
|
||||
|
||||
def __str__(self):
|
||||
return "{0} ({1})".format(self.username, self.uid)
|
||||
return '{0} ({1})'.format(self.username, self.uid)
|
||||
|
||||
@transaction.atomic
|
||||
def set_password(self, password):
|
||||
|
@ -217,15 +226,17 @@ class User(TimeStampedModel, models.Model):
|
|||
:param str password: the new password
|
||||
|
||||
"""
|
||||
if hasattr(self, "shadow"):
|
||||
if hasattr(self, 'shadow'):
|
||||
self.shadow.set_password(password)
|
||||
else:
|
||||
self.shadow = Shadow.objects.create_shadow(user=self, password=password)
|
||||
password_set.send(sender=self.__class__, password=password, instance=self)
|
||||
self.shadow = Shadow.objects.create_shadow(
|
||||
user=self, password=password
|
||||
)
|
||||
password_set.send(
|
||||
sender=self.__class__, password=password, instance=self)
|
||||
return True
|
||||
|
||||
def is_sftp_user(self):
|
||||
# noinspection PyUnresolvedReferences
|
||||
return self.additionalgroup_set.filter(
|
||||
group__groupname=settings.OSUSER_SFTP_GROUP
|
||||
).exists()
|
||||
|
@ -258,7 +269,6 @@ class User(TimeStampedModel, models.Model):
|
|||
:py:meth:`django.db.Model.delete`
|
||||
|
||||
"""
|
||||
# noinspection PyUnresolvedReferences
|
||||
self.group.delete()
|
||||
super(User, self).delete(*args, **kwargs)
|
||||
|
||||
|
@ -283,84 +293,64 @@ class ShadowManager(models.Manager):
|
|||
"""
|
||||
changedays = (timezone.now().date() - date(1970, 1, 1)).days
|
||||
shadow = self.create(
|
||||
user=user,
|
||||
changedays=changedays,
|
||||
minage=0,
|
||||
maxage=None,
|
||||
gracedays=7,
|
||||
inactdays=30,
|
||||
expiredays=None,
|
||||
user=user, changedays=changedays,
|
||||
minage=0, maxage=None, gracedays=7,
|
||||
inactdays=30, expiredays=None
|
||||
)
|
||||
shadow.set_password(password)
|
||||
shadow.save()
|
||||
return shadow
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Shadow(TimeStampedModel, models.Model):
|
||||
"""
|
||||
This entity class corresponds to an operating system user's shadow file
|
||||
entry.
|
||||
|
||||
"""
|
||||
|
||||
user = models.OneToOneField(
|
||||
User, primary_key=True, verbose_name=_("User"), on_delete=models.CASCADE
|
||||
)
|
||||
passwd = models.CharField(_("Encrypted password"), max_length=128)
|
||||
User, primary_key=True, verbose_name=_('User'),
|
||||
on_delete=models.CASCADE)
|
||||
passwd = models.CharField(_('Encrypted password'), max_length=128)
|
||||
changedays = models.PositiveSmallIntegerField(
|
||||
_("Date of last change"),
|
||||
help_text=_("This is expressed in days since Jan 1, 1970"),
|
||||
blank=True,
|
||||
null=True,
|
||||
)
|
||||
_('Date of last change'),
|
||||
help_text=_('This is expressed in days since Jan 1, 1970'),
|
||||
blank=True, null=True)
|
||||
minage = models.PositiveSmallIntegerField(
|
||||
_("Minimum age"),
|
||||
help_text=_("Minimum number of days before the password can be" " changed"),
|
||||
blank=True,
|
||||
null=True,
|
||||
)
|
||||
_('Minimum age'),
|
||||
help_text=_('Minimum number of days before the password can be'
|
||||
' changed'),
|
||||
blank=True, null=True)
|
||||
maxage = models.PositiveSmallIntegerField(
|
||||
_("Maximum age"),
|
||||
help_text=_(
|
||||
"Maximum number of days after which the password has to" " be changed"
|
||||
),
|
||||
blank=True,
|
||||
null=True,
|
||||
)
|
||||
_('Maximum age'),
|
||||
help_text=_('Maximum number of days after which the password has to'
|
||||
' be changed'),
|
||||
blank=True, null=True)
|
||||
gracedays = models.PositiveSmallIntegerField(
|
||||
_("Grace period"),
|
||||
help_text=_("The number of days before the password is going to" " expire"),
|
||||
blank=True,
|
||||
null=True,
|
||||
)
|
||||
_('Grace period'),
|
||||
help_text=_('The number of days before the password is going to'
|
||||
' expire'),
|
||||
blank=True, null=True)
|
||||
inactdays = models.PositiveSmallIntegerField(
|
||||
_("Inactivity period"),
|
||||
help_text=_(
|
||||
"The number of days after the password has expired during"
|
||||
" which the password should still be accepted"
|
||||
),
|
||||
blank=True,
|
||||
null=True,
|
||||
)
|
||||
_('Inactivity period'),
|
||||
help_text=_('The number of days after the password has expired during'
|
||||
' which the password should still be accepted'),
|
||||
blank=True, null=True)
|
||||
expiredays = models.PositiveSmallIntegerField(
|
||||
_("Account expiration date"),
|
||||
help_text=_(
|
||||
"The date of expiration of the account, expressed as"
|
||||
" number of days since Jan 1, 1970"
|
||||
),
|
||||
blank=True,
|
||||
null=True,
|
||||
default=None,
|
||||
)
|
||||
_('Account expiration date'),
|
||||
help_text=_('The date of expiration of the account, expressed as'
|
||||
' number of days since Jan 1, 1970'),
|
||||
blank=True, null=True, default=None)
|
||||
|
||||
objects = ShadowManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("Shadow password")
|
||||
verbose_name_plural = _("Shadow passwords")
|
||||
verbose_name = _('Shadow password')
|
||||
verbose_name_plural = _('Shadow passwords')
|
||||
|
||||
def __str__(self):
|
||||
return "for user {0}".format(self.user)
|
||||
return 'for user {0}'.format(self.user)
|
||||
|
||||
def set_password(self, password):
|
||||
"""
|
||||
|
@ -371,23 +361,23 @@ class Shadow(TimeStampedModel, models.Model):
|
|||
self.passwd = sha512_crypt.encrypt(password)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class AdditionalGroup(TimeStampedModel, models.Model):
|
||||
"""
|
||||
This entity class corresponds to additional group assignments for an
|
||||
:py:class:`operating system user <osusers.models.User>`.
|
||||
|
||||
"""
|
||||
|
||||
user = models.ForeignKey(User, on_delete=models.CASCADE)
|
||||
group = models.ForeignKey(Group, on_delete=models.CASCADE)
|
||||
|
||||
class Meta:
|
||||
unique_together = ("user", "group")
|
||||
verbose_name = _("Additional group")
|
||||
verbose_name_plural = _("Additional groups")
|
||||
unique_together = ('user', 'group')
|
||||
verbose_name = _('Additional group')
|
||||
verbose_name_plural = _('Additional groups')
|
||||
|
||||
def __str__(self):
|
||||
return "{0} in {1}".format(self.user, self.group)
|
||||
return '{0} in {1}'.format(self.user, self.group)
|
||||
|
||||
def clean(self):
|
||||
"""
|
||||
|
@ -395,7 +385,6 @@ class AdditionalGroup(TimeStampedModel, models.Model):
|
|||
group.
|
||||
|
||||
"""
|
||||
# noinspection PyUnresolvedReferences
|
||||
if self.user.group == self.group:
|
||||
raise ValidationError(CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL)
|
||||
|
||||
|
@ -434,62 +423,60 @@ class SshPublicKeyManager(models.Manager):
|
|||
|
||||
"""
|
||||
|
||||
def parse_key_text(self, key_text: str):
|
||||
def parse_keytext(self, keytext):
|
||||
"""
|
||||
Parse a SSH public key in OpenSSH or :rfc:`4716` format into its
|
||||
components algorithm, key data and comment.
|
||||
|
||||
:param str key_text: key text
|
||||
:param str keytext: key text
|
||||
:return: triple of algorithm name, key data and comment
|
||||
:rtype: triple of str
|
||||
|
||||
"""
|
||||
if key_text.startswith("---- BEGIN SSH2 PUBLIC KEY ----"):
|
||||
comment = ""
|
||||
data = ""
|
||||
continued = ""
|
||||
if keytext.startswith('---- BEGIN SSH2 PUBLIC KEY ----'):
|
||||
comment = ''
|
||||
data = ''
|
||||
continued = ''
|
||||
headers = {}
|
||||
header_tag = None
|
||||
for line in key_text.splitlines():
|
||||
if line == "---- BEGIN SSH2 PUBLIC KEY ----":
|
||||
for line in keytext.splitlines():
|
||||
if line == '---- BEGIN SSH2 PUBLIC KEY ----':
|
||||
continue
|
||||
elif ":" in line: # a header line
|
||||
elif ':' in line: # a header line
|
||||
header_tag, header_value = [
|
||||
item.strip() for item in line.split(":", 1)
|
||||
]
|
||||
if header_value.endswith("\\"):
|
||||
item.strip() for item in line.split(':', 1)]
|
||||
if header_value.endswith('\\'):
|
||||
continued = header_value[:-1]
|
||||
else:
|
||||
headers[header_tag.lower()] = header_value
|
||||
elif continued:
|
||||
if line.endswith("\\"):
|
||||
if line.endswith('\\'):
|
||||
continued += line[:-1]
|
||||
continue
|
||||
header_value = continued + line
|
||||
headers[header_tag.lower()] = header_value
|
||||
continued = ""
|
||||
elif line == "---- END SSH2 PUBLIC KEY ----":
|
||||
continued = ''
|
||||
elif line == '---- END SSH2 PUBLIC KEY ----':
|
||||
break
|
||||
elif line: # ignore empty lines
|
||||
data += line
|
||||
if "comment" in headers:
|
||||
comment = headers["comment"]
|
||||
if 'comment' in headers:
|
||||
comment = headers['comment']
|
||||
else:
|
||||
parts = key_text.split(None, 2)
|
||||
parts = keytext.split(None, 2)
|
||||
if len(parts) < 2:
|
||||
raise ValueError("invalid SSH public key")
|
||||
raise ValueError('invalid SSH public key')
|
||||
data = parts[1]
|
||||
comment = len(parts) == 3 and parts[2] or ""
|
||||
try:
|
||||
keybytes = base64.b64decode(data)
|
||||
except TypeError:
|
||||
raise ValueError("invalid SSH public key")
|
||||
parts = keybytes.split(b"\x00" * 3)
|
||||
raise ValueError('invalid SSH public key')
|
||||
parts = keybytes.split(b'\x00' * 3)
|
||||
if len(parts) < 2:
|
||||
raise ValueError("invalid SSH public key")
|
||||
key_length = int.from_bytes(parts[1], byteorder="big")
|
||||
key_algorithm = parts[1][1 : 1 + key_length].decode("utf-8")
|
||||
return key_algorithm, data, comment
|
||||
raise ValueError('invalid SSH public key')
|
||||
alglength = six.byte2int(parts[1])
|
||||
algname = parts[1][1:1+alglength]
|
||||
return algname, data, comment
|
||||
|
||||
def create_ssh_public_key(self, user, keytext):
|
||||
"""
|
||||
|
@ -503,28 +490,31 @@ class SshPublicKeyManager(models.Manager):
|
|||
:retype: :py:class:`osusers.models.SshPublicKey`
|
||||
|
||||
"""
|
||||
algorithm, data, comment = self.parse_key_text(keytext)
|
||||
return self.create(user=user, algorithm=algorithm, data=data, comment=comment)
|
||||
algorithm, data, comment = self.parse_keytext(keytext)
|
||||
return self.create(
|
||||
user=user, algorithm=algorithm, data=data, comment=comment)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class SshPublicKey(TimeStampedModel):
|
||||
"""
|
||||
This entity class represents single SSH keys for an :py:class:`operating
|
||||
system user <osusers.models.User>`.
|
||||
|
||||
"""
|
||||
|
||||
user = models.ForeignKey(User, verbose_name=_("User"), on_delete=models.CASCADE)
|
||||
algorithm = models.CharField(_("Algorithm"), max_length=20)
|
||||
data = models.TextField(_("Key bytes"), help_text=_("Base64 encoded key bytes"))
|
||||
comment = models.TextField(_("Comment"), blank=True)
|
||||
user = models.ForeignKey(
|
||||
User, verbose_name=_('User'), on_delete=models.CASCADE)
|
||||
algorithm = models.CharField(_('Algorithm'), max_length=20)
|
||||
data = models.TextField(_('Key bytes'),
|
||||
help_text=_('Base64 encoded key bytes'))
|
||||
comment = models.TextField(_('Comment'), blank=True)
|
||||
|
||||
objects = SshPublicKeyManager()
|
||||
|
||||
class Meta:
|
||||
verbose_name = _("SSH public key")
|
||||
verbose_name_plural = _("SSH public keys")
|
||||
unique_together = [("user", "algorithm", "data")]
|
||||
verbose_name = _('SSH public key')
|
||||
verbose_name_plural = _('SSH public keys')
|
||||
unique_together = [('user', 'algorithm', 'data')]
|
||||
|
||||
def __str__(self):
|
||||
return "{algorithm} {data} {comment}".format(
|
||||
|
|
|
@ -5,10 +5,17 @@ from django.test.utils import override_settings
|
|||
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
from osusers.forms import INVALID_SSH_PUBLIC_KEY, DUPLICATE_SSH_PUBLIC_KEY_FOR_USER
|
||||
from osusers.models import Group, SshPublicKey, User
|
||||
from osusers.forms import (
|
||||
INVALID_SSH_PUBLIC_KEY,
|
||||
DUPLICATE_SSH_PUBLIC_KEY_FOR_USER,
|
||||
)
|
||||
from osusers.models import (
|
||||
Group,
|
||||
SshPublicKey,
|
||||
User,
|
||||
)
|
||||
from osusers.admin import (
|
||||
GroupAdmin,
|
||||
PASSWORD_MISMATCH_ERROR,
|
||||
|
@ -23,19 +30,20 @@ Customer = get_user_model()
|
|||
|
||||
class CustomerTestCase(TestCase):
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user("test")
|
||||
self.customer = Customer.objects.create_user('test')
|
||||
super(CustomerTestCase, self).setUp()
|
||||
|
||||
|
||||
class UserCreationFormTest(CustomerTestCase):
|
||||
|
||||
def test_clean_password2_same(self):
|
||||
form = UserCreationForm()
|
||||
form.cleaned_data = {
|
||||
"customer": self.customer,
|
||||
"password1": "secret",
|
||||
"password2": "secret",
|
||||
'customer': self.customer,
|
||||
'password1': 'secret',
|
||||
'password2': 'secret'
|
||||
}
|
||||
self.assertEqual(form.clean_password2(), "secret")
|
||||
self.assertEqual(form.clean_password2(), 'secret')
|
||||
|
||||
def test_clean_password2_empty(self):
|
||||
form = UserCreationForm()
|
||||
|
@ -45,23 +53,25 @@ class UserCreationFormTest(CustomerTestCase):
|
|||
def test_clean_password2_mismatch(self):
|
||||
form = UserCreationForm()
|
||||
form.cleaned_data = {
|
||||
"customer": self.customer,
|
||||
"password1": "secretx",
|
||||
"password2": "secrety",
|
||||
'customer': self.customer,
|
||||
'password1': 'secretx',
|
||||
'password2': 'secrety'
|
||||
}
|
||||
with self.assertRaises(forms.ValidationError) as cm:
|
||||
form.clean_password2()
|
||||
self.assertEqual(cm.exception.message, PASSWORD_MISMATCH_ERROR)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_save_commit(self):
|
||||
form = UserCreationForm()
|
||||
form.cleaned_data = {
|
||||
"customer": self.customer,
|
||||
"password1": "secret",
|
||||
"password2": "secret",
|
||||
'customer': self.customer,
|
||||
'password1': 'secret',
|
||||
'password2': 'secret'
|
||||
}
|
||||
user = form.save()
|
||||
self.assertIsNotNone(user)
|
||||
|
@ -79,99 +89,121 @@ class UserAdminTest(CustomerTestCase):
|
|||
super(UserAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_without_object(self):
|
||||
form = self.uadmin.get_form(Mock(name="request"))
|
||||
self.assertEqual(form.Meta.fields, ["customer", "password1", "password2"])
|
||||
form = self.uadmin.get_form(Mock(name='request'))
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['customer', 'password1', 'password2']
|
||||
)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_get_form_with_object(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
form = self.uadmin.get_form(Mock(name="request"), user)
|
||||
form = self.uadmin.get_form(Mock(name='request'), user)
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
["username", "group", "gecos", "homedir", "shell", "customer", "uid"],
|
||||
['username', 'group', 'gecos', 'homedir', 'shell', 'customer',
|
||||
'uid']
|
||||
)
|
||||
|
||||
def test_get_inline_instances_without_object(self):
|
||||
inlines = self.uadmin.get_inline_instances(Mock(name="request"))
|
||||
inlines = self.uadmin.get_inline_instances(Mock(name='request'))
|
||||
self.assertEqual(len(inlines), 2)
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_get_inline_instances_with_object(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
inlines = self.uadmin.get_inline_instances(Mock(name="request"), user)
|
||||
inlines = self.uadmin.get_inline_instances(
|
||||
Mock(name='request'), user)
|
||||
self.assertEqual(len(inlines), len(UserAdmin.inlines))
|
||||
for index in range(len(inlines)):
|
||||
self.assertIsInstance(inlines[index], UserAdmin.inlines[index])
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_perform_delete_selected(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
self.uadmin.perform_delete_selected(
|
||||
Mock(name="request"), User.objects.filter(uid=user.uid)
|
||||
)
|
||||
Mock(name='request'), User.objects.filter(uid=user.uid))
|
||||
self.assertEqual(User.objects.filter(uid=user.uid).count(), 0)
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.uadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.uadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.uadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.uadmin.get_actions(requestmock))
|
||||
|
||||
|
||||
class GroupAdminTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.gadmin = GroupAdmin(Group, site)
|
||||
super(GroupAdminTest, self).setUp()
|
||||
|
||||
def test_get_inline_instances_without_object(self):
|
||||
inlines = self.gadmin.get_inline_instances(Mock(name="request"))
|
||||
inlines = self.gadmin.get_inline_instances(Mock(name='request'))
|
||||
self.assertEqual(inlines, [])
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
def test_get_inline_instances_with_object(self):
|
||||
group = Group.objects.create(gid=1000, groupname="test")
|
||||
inlines = self.gadmin.get_inline_instances(Mock(name="request"), group)
|
||||
group = Group.objects.create(gid=1000, groupname='test')
|
||||
inlines = self.gadmin.get_inline_instances(
|
||||
Mock(name='request'), group)
|
||||
self.assertEqual(len(inlines), len(GroupAdmin.inlines))
|
||||
for index in range(len(inlines)):
|
||||
self.assertIsInstance(inlines[index], GroupAdmin.inlines[index])
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
group = Group.objects.create(gid=1000, groupname="test")
|
||||
group = Group.objects.create(gid=1000, groupname='test')
|
||||
self.gadmin.perform_delete_selected(
|
||||
Mock(name="request"), Group.objects.filter(gid=group.gid)
|
||||
)
|
||||
Mock(name='request'), Group.objects.filter(gid=group.gid))
|
||||
self.assertEqual(Group.objects.filter(gid=group.gid).count(), 0)
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.gadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.gadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.gadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.gadmin.get_actions(requestmock))
|
||||
|
||||
|
||||
class SshPublicKeyCreationFormTest(CustomerTestCase):
|
||||
@patch("osusers.admin.SshPublicKey.objects")
|
||||
|
||||
@patch('osusers.admin.SshPublicKey.objects')
|
||||
def test_clean_publickeytext_valid_key(self, sshpkmanager):
|
||||
form = SshPublicKeyCreationForm()
|
||||
sshpkmanager.parse_key_text = MagicMock(side_effect=ValueError)
|
||||
form.cleaned_data = {"publickeytext": "wrongkey"}
|
||||
sshpkmanager.parse_keytext = MagicMock(side_effect=ValueError)
|
||||
form.cleaned_data = {'publickeytext': 'wrongkey'}
|
||||
with self.assertRaises(forms.ValidationError) as ve:
|
||||
form.clean_publickeytext()
|
||||
self.assertEqual(ve.exception.message, INVALID_SSH_PUBLIC_KEY)
|
||||
|
||||
@patch("osusers.admin.SshPublicKey.objects")
|
||||
@patch('osusers.admin.SshPublicKey.objects')
|
||||
def test_clean_publickeytext_invalid_key(self, sshpkmanager):
|
||||
form = SshPublicKeyCreationForm()
|
||||
sshpkmanager.parse_key_text = MagicMock(return_value="goodkey")
|
||||
form.cleaned_data = {"publickeytext": "goodkey"}
|
||||
self.assertEqual(form.clean_publickeytext(), "goodkey")
|
||||
sshpkmanager.parse_keytext = MagicMock(return_value='goodkey')
|
||||
form.cleaned_data = {'publickeytext': 'goodkey'}
|
||||
self.assertEqual(form.clean_publickeytext(), 'goodkey')
|
||||
|
||||
def test_clean_missing_data(self):
|
||||
form = SshPublicKeyCreationForm()
|
||||
|
@ -179,83 +211,95 @@ class SshPublicKeyCreationFormTest(CustomerTestCase):
|
|||
form.clean()
|
||||
self.assertEqual(len(form.errors), 0)
|
||||
|
||||
@patch("osusers.admin.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_once(self, parse_key_text):
|
||||
parse_key_text.return_value = ("good", "key", "comment")
|
||||
@patch('osusers.admin.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_once(self, parse_keytext):
|
||||
parse_keytext.return_value = ('good', 'key', 'comment')
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
form = SshPublicKeyCreationForm()
|
||||
form.cleaned_data = {"user": user, "publickeytext": "good key comment"}
|
||||
form.cleaned_data = {
|
||||
'user': user,
|
||||
'publickeytext': 'good key comment'
|
||||
}
|
||||
form.clean()
|
||||
self.assertEqual(len(form.errors), 0)
|
||||
|
||||
@patch("osusers.admin.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_again(self, parse_key_text):
|
||||
parse_key_text.return_value = ("good", "key", "comment")
|
||||
@patch('osusers.admin.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_again(self, parse_keytext):
|
||||
parse_keytext.return_value = ('good', 'key', 'comment')
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
SshPublicKey.objects.create(
|
||||
user=user, algorithm="good", data="key", comment="comment"
|
||||
)
|
||||
user=user, algorithm='good', data='key', comment='comment')
|
||||
form = SshPublicKeyCreationForm()
|
||||
form.cleaned_data = {"user": user, "publickeytext": "good key comment"}
|
||||
form.cleaned_data = {
|
||||
'user': user,
|
||||
'publickeytext': 'good key comment'
|
||||
}
|
||||
form.clean()
|
||||
self.assertIn("publickeytext", form.errors)
|
||||
self.assertIn('publickeytext', form.errors)
|
||||
self.assertEqual(
|
||||
form.errors["publickeytext"], [DUPLICATE_SSH_PUBLIC_KEY_FOR_USER]
|
||||
)
|
||||
form.errors['publickeytext'],
|
||||
[DUPLICATE_SSH_PUBLIC_KEY_FOR_USER])
|
||||
|
||||
@patch("osusers.admin.SshPublicKey.objects.parse_key_text")
|
||||
def test_save(self, parse_key_text):
|
||||
parse_key_text.return_value = ("good", "key", "comment")
|
||||
@patch('osusers.admin.SshPublicKey.objects.parse_keytext')
|
||||
def test_save(self, parse_keytext):
|
||||
parse_keytext.return_value = ('good', 'key', 'comment')
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
form = SshPublicKeyCreationForm()
|
||||
form.cleaned_data = {"user": user, "publickeytext": "good key comment"}
|
||||
form.cleaned_data = {
|
||||
'user': user,
|
||||
'publickeytext': 'good key comment'
|
||||
}
|
||||
form.instance.user = user
|
||||
form.save()
|
||||
self.assertTrue(
|
||||
SshPublicKey.objects.filter(user=user, algorithm="good", data="key")
|
||||
)
|
||||
SshPublicKey.objects.filter(
|
||||
user=user, algorithm='good', data='key'))
|
||||
|
||||
|
||||
class SshPublicKeyAdminTest(CustomerTestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.sadmin = SshPublicKeyAdmin(SshPublicKey, site)
|
||||
super(SshPublicKeyAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_no_instance(self):
|
||||
form = self.sadmin.get_form(request=Mock(name="request"))
|
||||
form = self.sadmin.get_form(request=Mock(name='request'))
|
||||
self.assertEqual(form.Meta.model, SshPublicKey)
|
||||
|
||||
def test_get_form_with_instance(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
key = SshPublicKey.objects.create(
|
||||
user=user, algorithm="good", data="key", comment="comment"
|
||||
)
|
||||
form = self.sadmin.get_form(request=Mock(name="request"), obj=key)
|
||||
user=user, algorithm='good', data='key', comment='comment')
|
||||
form = self.sadmin.get_form(request=Mock(name='request'), obj=key)
|
||||
self.assertEqual(form.Meta.model, SshPublicKey)
|
||||
self.assertEqual(form.Meta.fields, ["user", "comment", "algorithm", "data"])
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['user', 'comment', 'algorithm', 'data'])
|
||||
|
||||
def test_get_readonly_fields_no_instance(self):
|
||||
readonly_fields = self.sadmin.get_readonly_fields(request=Mock(name="request"))
|
||||
readonly_fields = self.sadmin.get_readonly_fields(
|
||||
request=Mock(name='request'))
|
||||
self.assertEqual(readonly_fields, [])
|
||||
|
||||
def test_get_readonly_fields_with_instance(self):
|
||||
readonly_fields = self.sadmin.get_readonly_fields(
|
||||
request=Mock(name="request"), obj=Mock()
|
||||
)
|
||||
self.assertEqual(readonly_fields, ["algorithm", "data"])
|
||||
request=Mock(name='request'), obj=Mock())
|
||||
self.assertEqual(readonly_fields, ['algorithm', 'data'])
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
key = SshPublicKey.objects.create(
|
||||
user=user, algorithm="good", data="key", comment="comment"
|
||||
)
|
||||
user=user, algorithm='good', data='key', comment='comment')
|
||||
self.sadmin.perform_delete_selected(
|
||||
Mock(name="request"), SshPublicKey.objects.filter(id=key.id)
|
||||
)
|
||||
Mock(name='request'), SshPublicKey.objects.filter(id=key.id))
|
||||
self.assertFalse(SshPublicKey.objects.filter(id=key.id).exists())
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.sadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.sadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.sadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.sadmin.get_actions(requestmock))
|
||||
|
|
|
@ -2,13 +2,15 @@
|
|||
This module provides tests for :py:mod:`osusers.forms`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
from django import forms
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.urls import reverse
|
||||
|
||||
from passlib.hash import sha512_crypt
|
||||
|
||||
|
@ -32,7 +34,7 @@ class AddSshPublicKeyFormTest(TestCase):
|
|||
"""
|
||||
|
||||
def _setup_hostingpackage(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer=customer)
|
||||
self.hostingpackage = Mock(id=42, osuser=user)
|
||||
|
||||
|
@ -40,92 +42,97 @@ class AddSshPublicKeyFormTest(TestCase):
|
|||
instance = MagicMock()
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
AddSshPublicKeyForm(instance)
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
|
||||
def test_constructor(self):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
self.assertTrue(hasattr(form, "osuser"))
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
self.assertTrue(hasattr(form, 'osuser'))
|
||||
self.assertEqual(form.osuser, self.hostingpackage.osuser)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_ssh_key", kwargs={"package": self.hostingpackage.id}),
|
||||
)
|
||||
self.assertIn("publickeytext", form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_ssh_key', kwargs={'package': self.hostingpackage.id}))
|
||||
self.assertIn('publickeytext', form.fields)
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
@patch("osusers.forms.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_publickeytext_invalid(self, parse_key_text):
|
||||
@patch('osusers.forms.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_publickeytext_invalid(self, parse_keytext):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {"publickeytext": "a bad key"}
|
||||
parse_key_text.side_effect = ValueError
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {'publickeytext': 'a bad key'}
|
||||
parse_keytext.side_effect = ValueError
|
||||
with self.assertRaises(forms.ValidationError) as ve:
|
||||
form.clean_publickeytext()
|
||||
self.assertEqual(ve.exception.message, INVALID_SSH_PUBLIC_KEY)
|
||||
|
||||
@patch("osusers.forms.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_publickeytext_valid(self, _):
|
||||
@patch('osusers.forms.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_publickeytext_valid(self, parse_keytext):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {"publickeytext": "good key comment"}
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {'publickeytext': 'good key comment'}
|
||||
retval = form.clean_publickeytext()
|
||||
self.assertEqual(retval, "good key comment")
|
||||
self.assertEqual(retval, 'good key comment')
|
||||
|
||||
def test_clean_none(self):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {"publickeytext": None}
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {'publickeytext': None}
|
||||
form.clean()
|
||||
self.assertIsNone(form.cleaned_data["publickeytext"])
|
||||
self.assertIsNone(form.cleaned_data['publickeytext'])
|
||||
|
||||
@patch("osusers.forms.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_fresh(self, parse_key_text):
|
||||
@patch('osusers.forms.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_fresh(self, parse_keytext):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
sshpubkey = "good key comment"
|
||||
form.cleaned_data = {"publickeytext": sshpubkey}
|
||||
parse_key_text.return_value = sshpubkey.split(" ")
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
sshpubkey = 'good key comment'
|
||||
form.cleaned_data = {'publickeytext': sshpubkey}
|
||||
parse_keytext.return_value = sshpubkey.split(' ')
|
||||
form.clean()
|
||||
self.assertEqual(form.cleaned_data["publickeytext"], "good key comment")
|
||||
self.assertEqual(
|
||||
form.cleaned_data['publickeytext'], 'good key comment')
|
||||
|
||||
@patch("osusers.forms.SshPublicKey.objects.parse_key_text")
|
||||
def test_clean_duplicate(self, parse_key_text):
|
||||
@patch('osusers.forms.SshPublicKey.objects.parse_keytext')
|
||||
def test_clean_duplicate(self, parse_keytext):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
SshPublicKey.objects.create(
|
||||
user=self.hostingpackage.osuser,
|
||||
algorithm="good",
|
||||
data="key",
|
||||
comment="comment",
|
||||
)
|
||||
sshpubkey = "good key comment"
|
||||
form.cleaned_data = {"publickeytext": sshpubkey}
|
||||
parse_key_text.return_value = sshpubkey.split(" ")
|
||||
user=self.hostingpackage.osuser, algorithm='good', data='key',
|
||||
comment='comment')
|
||||
sshpubkey = 'good key comment'
|
||||
form.cleaned_data = {'publickeytext': sshpubkey}
|
||||
parse_keytext.return_value = sshpubkey.split(' ')
|
||||
form.clean()
|
||||
self.assertIn("publickeytext", form.errors)
|
||||
self.assertIn(DUPLICATE_SSH_PUBLIC_KEY_FOR_USER, form.errors["publickeytext"])
|
||||
self.assertIn('publickeytext', form.errors)
|
||||
self.assertIn(
|
||||
DUPLICATE_SSH_PUBLIC_KEY_FOR_USER,
|
||||
form.errors['publickeytext'])
|
||||
|
||||
@patch("osusers.admin.SshPublicKey.objects.parse_key_text")
|
||||
def test_save(self, parse_key_text):
|
||||
@patch('osusers.admin.SshPublicKey.objects.parse_keytext')
|
||||
def test_save(self, parse_keytext):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
form = AddSshPublicKeyForm(instance, hostingpackage=self.hostingpackage)
|
||||
sshpubkey = "good key comment"
|
||||
form.cleaned_data = {"publickeytext": sshpubkey}
|
||||
parse_key_text.return_value = sshpubkey.split(" ")
|
||||
form = AddSshPublicKeyForm(
|
||||
instance, hostingpackage=self.hostingpackage)
|
||||
sshpubkey = 'good key comment'
|
||||
form.cleaned_data = {'publickeytext': sshpubkey}
|
||||
parse_keytext.return_value = sshpubkey.split(' ')
|
||||
retval = form.save()
|
||||
self.assertTrue(isinstance(retval, SshPublicKey))
|
||||
self.assertEqual(retval.algorithm, "good")
|
||||
self.assertEqual(retval.data, "key")
|
||||
self.assertEqual(retval.comment, "comment")
|
||||
self.assertEqual(retval.algorithm, 'good')
|
||||
self.assertEqual(retval.data, 'key')
|
||||
self.assertEqual(retval.comment, 'comment')
|
||||
|
||||
|
||||
class ChangeOsUserPasswordFormTest(TestCase):
|
||||
|
@ -135,27 +142,25 @@ class ChangeOsUserPasswordFormTest(TestCase):
|
|||
"""
|
||||
|
||||
def _setup_user(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
self.user = User.objects.create_user(customer=customer)
|
||||
|
||||
def test_constructor(self):
|
||||
self._setup_user()
|
||||
form = ChangeOsUserPasswordForm(instance=self.user)
|
||||
self.assertTrue(hasattr(form, "instance"))
|
||||
self.assertTrue(hasattr(form, 'instance'))
|
||||
self.assertEqual(form.instance, self.user)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("set_osuser_password", kwargs={"slug": self.user.username}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'set_osuser_password', kwargs={'slug': self.user.username}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
def test_save(self):
|
||||
self._setup_user()
|
||||
form = ChangeOsUserPasswordForm(instance=self.user)
|
||||
form.cleaned_data = {"password1": "test"}
|
||||
form.cleaned_data = {'password1': 'test'}
|
||||
user = form.save()
|
||||
self.assertTrue(sha512_crypt.verify("test", user.shadow.passwd))
|
||||
self.assertTrue(sha512_crypt.verify('test', user.shadow.passwd))
|
||||
|
||||
|
||||
class EditSshPublicKeyCommentFormTest(TestCase):
|
||||
|
@ -165,7 +170,7 @@ class EditSshPublicKeyCommentFormTest(TestCase):
|
|||
"""
|
||||
|
||||
def _setup_hostingpackage(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer=customer)
|
||||
self.hostingpackage = Mock(id=42, osuser=user)
|
||||
|
||||
|
@ -173,23 +178,18 @@ class EditSshPublicKeyCommentFormTest(TestCase):
|
|||
instance = MagicMock()
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
EditSshPublicKeyCommentForm(instance)
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
|
||||
def test_constructor(self):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock(id=1)
|
||||
form = EditSshPublicKeyCommentForm(
|
||||
instance=instance, hostingpackage=self.hostingpackage
|
||||
)
|
||||
self.assertTrue(hasattr(form, "osuser"))
|
||||
instance=instance, hostingpackage=self.hostingpackage)
|
||||
self.assertTrue(hasattr(form, 'osuser'))
|
||||
self.assertEqual(form.osuser, self.hostingpackage.osuser)
|
||||
self.assertIn("comment", form.fields)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse(
|
||||
"edit_ssh_key_comment",
|
||||
kwargs={"package": self.hostingpackage.id, "pk": instance.id},
|
||||
),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
self.assertIn('comment', form.fields)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'edit_ssh_key_comment',
|
||||
kwargs={'package': self.hostingpackage.id, 'pk': instance.id}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
|
|
@ -1,17 +1,19 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
from datetime import date
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.exceptions import ValidationError
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
from django.utils import timezone
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
from passlib.hash import sha512_crypt
|
||||
|
||||
from osusers.models import (
|
||||
AdditionalGroup,
|
||||
CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL,
|
||||
AdditionalGroup,
|
||||
Group,
|
||||
Shadow,
|
||||
SshPublicKey,
|
||||
|
@ -19,6 +21,7 @@ from osusers.models import (
|
|||
)
|
||||
from taskresults.models import TaskResult
|
||||
|
||||
|
||||
EXAMPLE_KEY_1_RFC4716 = """---- BEGIN SSH2 PUBLIC KEY ----
|
||||
Comment: "1024-bit RSA, converted from OpenSSH by me@example.com"
|
||||
x-command: /home/me/bin/lock-in-guest.sh
|
||||
|
@ -54,14 +57,12 @@ n24VYtYtsMu74qXviYjziVucWKjjKEb11juqnF0GDlB3VVmxHLmxnAz643WK42Z7dLM5
|
|||
sY29ouezv4Xz2PuMch5VGPP+CDqzCM4loWgV
|
||||
---- END SSH2 PUBLIC KEY ----"""
|
||||
|
||||
EXAMPLE_KEY_4_OPENSSH = "".join(
|
||||
(
|
||||
"ssh-rsa ",
|
||||
"AAAAB3NzaC1yc2EAAAABIwAAAIEA1on8gxCGJJWSRT4uOrR13mUaUk0hRf4RzxSZ1zRb",
|
||||
"YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ",
|
||||
"5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE=",
|
||||
)
|
||||
)
|
||||
EXAMPLE_KEY_4_OPENSSH = "".join((
|
||||
"ssh-rsa ",
|
||||
"AAAAB3NzaC1yc2EAAAABIwAAAIEA1on8gxCGJJWSRT4uOrR13mUaUk0hRf4RzxSZ1zRb",
|
||||
"YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ",
|
||||
"5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE="
|
||||
))
|
||||
|
||||
EXAMPLE_KEY_5_RFC4716_MULTILINE = """---- BEGIN SSH2 PUBLIC KEY ----
|
||||
Comment: DSA Public Key \\
|
||||
|
@ -98,7 +99,10 @@ YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ
|
|||
5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE=
|
||||
---- END SSH2 PUBLIC KEY ----"""
|
||||
|
||||
EXAMPLE_KEY_8_OPENSSH_BROKEN = "".join(("ssh-rsa ", "AschrÖdderöd"))
|
||||
EXAMPLE_KEY_8_OPENSSH_BROKEN = "".join((
|
||||
"ssh-rsa ",
|
||||
"AschrÖdderöd"
|
||||
))
|
||||
|
||||
EXAMPLE_KEY_9_RFC4716_ONLY_HEADER = "---- BEGIN SSH2 PUBLIC KEY ----"
|
||||
|
||||
|
@ -106,7 +110,9 @@ Customer = get_user_model()
|
|||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class TestCaseWithCeleryTasks(TestCase):
|
||||
pass
|
||||
|
@ -114,44 +120,38 @@ class TestCaseWithCeleryTasks(TestCase):
|
|||
|
||||
class AdditionalGroupTest(TestCaseWithCeleryTasks):
|
||||
def setUp(self):
|
||||
customer = Customer.objects.create(username="test")
|
||||
self.group1 = Group.objects.create(groupname="test1", gid=1000)
|
||||
customer = Customer.objects.create(username='test')
|
||||
self.group1 = Group.objects.create(groupname='test1', gid=1000)
|
||||
self.user = User.objects.create(
|
||||
customer=customer,
|
||||
username="test",
|
||||
uid=1000,
|
||||
group=self.group1,
|
||||
homedir="/home/test",
|
||||
shell="/bin/bash",
|
||||
)
|
||||
customer=customer, username='test', uid=1000, group=self.group1,
|
||||
homedir='/home/test', shell='/bin/bash')
|
||||
|
||||
def test_clean_primary_group(self):
|
||||
testsubj = AdditionalGroup(user=self.user, group=self.group1)
|
||||
with self.assertRaises(ValidationError) as cm:
|
||||
testsubj.clean()
|
||||
self.assertEqual(cm.exception.message, CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL)
|
||||
self.assertEqual(
|
||||
cm.exception.message, CANNOT_USE_PRIMARY_GROUP_AS_ADDITIONAL)
|
||||
|
||||
def test_clean_other_group(self):
|
||||
group2 = Group.objects.create(groupname="test2", gid=1001)
|
||||
group2 = Group.objects.create(groupname='test2', gid=1001)
|
||||
testsubj = AdditionalGroup(user=self.user, group=group2)
|
||||
testsubj.clean()
|
||||
|
||||
def test_save(self):
|
||||
group2 = Group.objects.create(groupname="test2", gid=1001)
|
||||
group2 = Group.objects.create(groupname='test2', gid=1001)
|
||||
addgroup = AdditionalGroup(user=self.user, group=group2)
|
||||
addgroup.save()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertTrue(len(taskres), 4)
|
||||
creators = [r.creator for r in taskres]
|
||||
for tcount, tcreator in [
|
||||
(2, "handle_group_created"),
|
||||
(1, "handle_user_created"),
|
||||
(1, "handle_user_added_to_group"),
|
||||
]:
|
||||
(2, 'handle_group_created'), (1, 'handle_user_created'),
|
||||
(1, 'handle_user_added_to_group')]:
|
||||
self.assertEqual(creators.count(tcreator), tcount)
|
||||
|
||||
def test_save_again(self):
|
||||
group2 = Group.objects.create(groupname="test2", gid=1001)
|
||||
group2 = Group.objects.create(groupname='test2', gid=1001)
|
||||
TaskResult.objects.all().delete()
|
||||
addgroup = AdditionalGroup(user=self.user, group=group2)
|
||||
addgroup.save()
|
||||
|
@ -161,18 +161,15 @@ class AdditionalGroupTest(TestCaseWithCeleryTasks):
|
|||
self.assertEqual(len(taskres), 0)
|
||||
|
||||
def test_delete(self):
|
||||
group2 = Group.objects.create(groupname="test2", gid=1001)
|
||||
# noinspection PyUnresolvedReferences
|
||||
group2 = Group.objects.create(groupname='test2', gid=1001)
|
||||
addgroup = AdditionalGroup.objects.create(user=self.user, group=group2)
|
||||
addgroup.delete()
|
||||
# noinspection PyUnresolvedReferences
|
||||
self.assertEqual(len(AdditionalGroup.objects.all()), 0)
|
||||
|
||||
def test___str__(self):
|
||||
group2 = Group.objects.create(groupname="test2", gid=1001)
|
||||
# noinspection PyUnresolvedReferences
|
||||
group2 = Group.objects.create(groupname='test2', gid=1001)
|
||||
addgroup = AdditionalGroup.objects.create(user=self.user, group=group2)
|
||||
self.assertEqual(str(addgroup), "test (1000) in test2 (1001)")
|
||||
self.assertEqual(str(addgroup), 'test (1000) in test2 (1001)')
|
||||
|
||||
|
||||
@override_settings(OSUSER_MINGID=10000)
|
||||
|
@ -181,61 +178,56 @@ class GroupManagerTest(TestCaseWithCeleryTasks):
|
|||
self.assertEqual(Group.objects.get_next_gid(), 10000)
|
||||
|
||||
def test_get_next_gid_second(self):
|
||||
Group.objects.create(gid=10010, groupname="test")
|
||||
Group.objects.create(gid=10010, groupname='test')
|
||||
self.assertEqual(Group.objects.get_next_gid(), 10011)
|
||||
|
||||
|
||||
class GroupTest(TestCaseWithCeleryTasks):
|
||||
def test___str__(self):
|
||||
group = Group.objects.create(gid=10000, groupname="test")
|
||||
self.assertEqual(str(group), "test (10000)")
|
||||
group = Group.objects.create(gid=10000, groupname='test')
|
||||
self.assertEqual(str(group), 'test (10000)')
|
||||
|
||||
def test_save(self):
|
||||
group = Group(gid=10000, groupname="test")
|
||||
group = Group(gid=10000, groupname='test')
|
||||
self.assertIs(group.save(), group)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertTrue(len(taskres), 1)
|
||||
creators = [r.creator for r in taskres]
|
||||
for tcount, tcreator in [(1, "handle_group_created")]:
|
||||
for tcount, tcreator in [
|
||||
(1, 'handle_group_created')]:
|
||||
self.assertEqual(creators.count(tcreator), tcount)
|
||||
|
||||
def test_save_again(self):
|
||||
group = Group.objects.create(gid=10000, groupname="test")
|
||||
TaskResult.objects.all().delete()
|
||||
group = Group.objects.create(gid=10000, groupname='test')
|
||||
taskres = TaskResult.objects.all().delete()
|
||||
group.save()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 0)
|
||||
|
||||
def test_delete(self):
|
||||
group = Group.objects.create(gid=10000, groupname="test")
|
||||
group = Group.objects.create(gid=10000, groupname='test')
|
||||
self.assertEqual(len(Group.objects.all()), 1)
|
||||
group.delete()
|
||||
self.assertEqual(len(Group.objects.all()), 0)
|
||||
self.assertEqual(len(TaskResult.objects.all()), 2)
|
||||
tr = TaskResult.objects.first()
|
||||
self.assertEqual(tr.creator, "handle_group_created")
|
||||
self.assertEqual(tr.creator, 'handle_group_created')
|
||||
|
||||
|
||||
class ShadowManagerTest(TestCaseWithCeleryTasks):
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create(username="test")
|
||||
self.customer = Customer.objects.create(username='test')
|
||||
super(ShadowManagerTest, self).setUp()
|
||||
|
||||
def test_create_shadow(self):
|
||||
group = Group.objects.create(gid=1000, groupname="test")
|
||||
user = User.objects.create(
|
||||
customer=self.customer,
|
||||
username="test",
|
||||
uid=1000,
|
||||
group=group,
|
||||
homedir="/home/test",
|
||||
shell="/bin/fooshell",
|
||||
)
|
||||
shadow = Shadow.objects.create_shadow(user, "test")
|
||||
self.assertTrue(sha512_crypt.verify("test", shadow.passwd))
|
||||
self.assertEqual(
|
||||
shadow.changedays, (timezone.now().date() - date(1970, 1, 1)).days
|
||||
)
|
||||
user = User(
|
||||
customer=self.customer, username='test', uid=1000,
|
||||
group=Group(gid=1000, groupname='test'), homedir='/home/test',
|
||||
shell='/bin/fooshell')
|
||||
shadow = Shadow.objects.create_shadow(user, 'test')
|
||||
self.assertTrue(sha512_crypt.verify('test', shadow.passwd))
|
||||
self.assertEqual(shadow.changedays,
|
||||
(timezone.now().date() - date(1970, 1, 1)).days)
|
||||
self.assertEqual(shadow.user, user)
|
||||
self.assertEqual(shadow.minage, 0)
|
||||
self.assertIsNone(shadow.maxage)
|
||||
|
@ -246,50 +238,39 @@ class ShadowManagerTest(TestCaseWithCeleryTasks):
|
|||
|
||||
class ShadowTest(TestCaseWithCeleryTasks):
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create(username="test")
|
||||
self.customer = Customer.objects.create(username='test')
|
||||
super(ShadowTest, self).setUp()
|
||||
|
||||
def test___str__(self):
|
||||
group = Group.objects.create(groupname="test", gid=1000)
|
||||
group = Group.objects.create(
|
||||
groupname='test', gid=1000)
|
||||
user = User.objects.create(
|
||||
customer=self.customer,
|
||||
username="test",
|
||||
uid=1000,
|
||||
group=group,
|
||||
homedir="/home/test",
|
||||
shell="/bin/bash",
|
||||
)
|
||||
customer=self.customer, username='test', uid=1000, group=group,
|
||||
homedir='/home/test', shell='/bin/bash')
|
||||
shadow = Shadow(user=user)
|
||||
self.assertEqual(str(shadow), "for user test (1000)")
|
||||
self.assertEqual(str(shadow), 'for user test (1000)')
|
||||
|
||||
def test_set_password(self):
|
||||
group = Group.objects.create(groupname="test", gid=1000)
|
||||
group = Group.objects.create(
|
||||
groupname='test', gid=1000)
|
||||
user = User.objects.create(
|
||||
customer=self.customer,
|
||||
username="test",
|
||||
uid=1000,
|
||||
group=group,
|
||||
homedir="/home/test",
|
||||
shell="/bin/bash",
|
||||
)
|
||||
customer=self.customer, username='test', uid=1000, group=group,
|
||||
homedir='/home/test', shell='/bin/bash')
|
||||
shadow = Shadow(user=user)
|
||||
shadow.set_password("test")
|
||||
self.assertTrue(sha512_crypt.verify("test", shadow.passwd))
|
||||
shadow.set_password('test')
|
||||
self.assertTrue(sha512_crypt.verify('test', shadow.passwd))
|
||||
|
||||
|
||||
@override_settings(
|
||||
OSUSER_MINUID=10000,
|
||||
OSUSER_MINGID=10000,
|
||||
OSUSER_USERNAME_PREFIX="test",
|
||||
OSUSER_HOME_BASEPATH="/home",
|
||||
OSUSER_DEFAULT_SHELL="/bin/fooshell",
|
||||
OSUSER_MINUID=10000, OSUSER_MINGID=10000, OSUSER_USERNAME_PREFIX='test',
|
||||
OSUSER_HOME_BASEPATH='/home', OSUSER_DEFAULT_SHELL='/bin/fooshell'
|
||||
)
|
||||
class UserManagerTest(TestCaseWithCeleryTasks):
|
||||
def _create_group(self):
|
||||
return Group.objects.create(gid=10000, groupname="foo")
|
||||
return Group.objects.create(gid=10000, groupname='foo')
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create(username="test")
|
||||
self.customer = Customer.objects.create(username='test')
|
||||
super(UserManagerTest, self).setUp()
|
||||
|
||||
def test_get_next_uid_first(self):
|
||||
|
@ -297,58 +278,40 @@ class UserManagerTest(TestCaseWithCeleryTasks):
|
|||
|
||||
def test_get_next_uid_second(self):
|
||||
User.objects.create(
|
||||
customer=self.customer,
|
||||
uid=10010,
|
||||
username="foo",
|
||||
group=self._create_group(),
|
||||
homedir="/home/foo",
|
||||
shell="/bin/fooshell",
|
||||
)
|
||||
customer=self.customer, uid=10010, username='foo',
|
||||
group=self._create_group(), homedir='/home/foo',
|
||||
shell='/bin/fooshell')
|
||||
self.assertEqual(User.objects.get_next_uid(), 10011)
|
||||
|
||||
def test_get_next_username_first(self):
|
||||
self.assertEqual(User.objects.get_next_username(), "test01")
|
||||
self.assertEqual(User.objects.get_next_username(), 'test01')
|
||||
|
||||
def test_get_next_username_second(self):
|
||||
User.objects.create(
|
||||
customer=self.customer,
|
||||
uid=10000,
|
||||
username="test01",
|
||||
group=self._create_group(),
|
||||
homedir="/home/foo",
|
||||
shell="/bin/fooshell",
|
||||
)
|
||||
self.assertEqual(User.objects.get_next_username(), "test02")
|
||||
customer=self.customer, uid=10000, username='test01',
|
||||
group=self._create_group(), homedir='/home/foo',
|
||||
shell='/bin/fooshell')
|
||||
self.assertEqual(User.objects.get_next_username(), 'test02')
|
||||
|
||||
def test_get_next_username_gaps(self):
|
||||
group = self._create_group()
|
||||
User.objects.create(
|
||||
customer=self.customer,
|
||||
uid=10000,
|
||||
username="test01",
|
||||
group=group,
|
||||
homedir="/home/foo",
|
||||
shell="/bin/fooshell",
|
||||
)
|
||||
customer=self.customer, uid=10000, username='test01', group=group,
|
||||
homedir='/home/foo', shell='/bin/fooshell')
|
||||
User.objects.create(
|
||||
customer=self.customer,
|
||||
uid=10002,
|
||||
username="test03",
|
||||
group=group,
|
||||
homedir="/home/foo",
|
||||
shell="/bin/fooshell",
|
||||
)
|
||||
self.assertEqual(User.objects.get_next_username(), "test02")
|
||||
customer=self.customer, uid=10002, username='test03', group=group,
|
||||
homedir='/home/foo', shell='/bin/fooshell')
|
||||
self.assertEqual(User.objects.get_next_username(), 'test02')
|
||||
|
||||
def test_create_user_first(self):
|
||||
user = User.objects.create_user(customer=self.customer)
|
||||
self.assertIsInstance(user, User)
|
||||
self.assertEqual(user.uid, 10000)
|
||||
self.assertEqual(user.group.gid, 10000)
|
||||
self.assertEqual(user.group.groupname, "test01")
|
||||
self.assertEqual(user.username, "test01")
|
||||
self.assertEqual(user.homedir, "/home/test01")
|
||||
self.assertEqual(user.shell, "/bin/fooshell")
|
||||
self.assertEqual(user.group.groupname, 'test01')
|
||||
self.assertEqual(user.username, 'test01')
|
||||
self.assertEqual(user.homedir, '/home/test01')
|
||||
self.assertEqual(user.shell, '/bin/fooshell')
|
||||
self.assertIsNotNone(user.shadow)
|
||||
|
||||
def test_create_user_tasks(self):
|
||||
|
@ -357,10 +320,8 @@ class UserManagerTest(TestCaseWithCeleryTasks):
|
|||
self.assertEqual(len(taskres), 3)
|
||||
creators = [r.creator for r in taskres]
|
||||
for creator in [
|
||||
"handle_group_created",
|
||||
"handle_user_created",
|
||||
"handle_user_password_set",
|
||||
]:
|
||||
'handle_group_created', 'handle_user_created',
|
||||
'handle_user_password_set']:
|
||||
self.assertIn(creator, creators)
|
||||
|
||||
def test_create_user_second(self):
|
||||
|
@ -369,34 +330,36 @@ class UserManagerTest(TestCaseWithCeleryTasks):
|
|||
self.assertIsInstance(user, User)
|
||||
self.assertEqual(user.uid, 10001)
|
||||
self.assertEqual(user.group.gid, 10001)
|
||||
self.assertEqual(user.group.groupname, "test02")
|
||||
self.assertEqual(user.username, "test02")
|
||||
self.assertEqual(user.homedir, "/home/test02")
|
||||
self.assertEqual(user.shell, "/bin/fooshell")
|
||||
self.assertEqual(user.group.groupname, 'test02')
|
||||
self.assertEqual(user.username, 'test02')
|
||||
self.assertEqual(user.homedir, '/home/test02')
|
||||
self.assertEqual(user.shell, '/bin/fooshell')
|
||||
self.assertIsNotNone(user.shadow)
|
||||
self.assertEqual(len(User.objects.all()), 2)
|
||||
|
||||
def test_create_user_known_password(self):
|
||||
user = User.objects.create_user(customer=self.customer, password="foobar")
|
||||
user = User.objects.create_user(
|
||||
customer=self.customer, password='foobar')
|
||||
self.assertIsInstance(user, User)
|
||||
self.assertEqual(user.uid, 10000)
|
||||
self.assertEqual(user.group.gid, 10000)
|
||||
self.assertEqual(user.group.groupname, "test01")
|
||||
self.assertEqual(user.username, "test01")
|
||||
self.assertEqual(user.homedir, "/home/test01")
|
||||
self.assertEqual(user.shell, "/bin/fooshell")
|
||||
self.assertEqual(user.group.groupname, 'test01')
|
||||
self.assertEqual(user.username, 'test01')
|
||||
self.assertEqual(user.homedir, '/home/test01')
|
||||
self.assertEqual(user.shell, '/bin/fooshell')
|
||||
self.assertIsNotNone(user.shadow)
|
||||
self.assertTrue(sha512_crypt.verify("foobar", user.shadow.passwd))
|
||||
self.assertTrue(sha512_crypt.verify('foobar', user.shadow.passwd))
|
||||
|
||||
def test_create_user_predefined_username(self):
|
||||
user = User.objects.create_user(customer=self.customer, username="tester")
|
||||
user = User.objects.create_user(
|
||||
customer=self.customer, username='tester')
|
||||
self.assertIsInstance(user, User)
|
||||
self.assertEqual(user.uid, 10000)
|
||||
self.assertEqual(user.group.gid, 10000)
|
||||
self.assertEqual(user.group.groupname, "tester")
|
||||
self.assertEqual(user.username, "tester")
|
||||
self.assertEqual(user.homedir, "/home/tester")
|
||||
self.assertEqual(user.shell, "/bin/fooshell")
|
||||
self.assertEqual(user.group.groupname, 'tester')
|
||||
self.assertEqual(user.username, 'tester')
|
||||
self.assertEqual(user.homedir, '/home/tester')
|
||||
self.assertEqual(user.shell, '/bin/fooshell')
|
||||
self.assertIsNotNone(user.shadow)
|
||||
|
||||
def test_create_user_commit(self):
|
||||
|
@ -404,34 +367,31 @@ class UserManagerTest(TestCaseWithCeleryTasks):
|
|||
self.assertIsInstance(user, User)
|
||||
self.assertEqual(user.uid, 10000)
|
||||
self.assertEqual(user.group.gid, 10000)
|
||||
self.assertEqual(user.group.groupname, "test01")
|
||||
self.assertEqual(user.username, "test01")
|
||||
self.assertEqual(user.homedir, "/home/test01")
|
||||
self.assertEqual(user.shell, "/bin/fooshell")
|
||||
self.assertEqual(user.group.groupname, 'test01')
|
||||
self.assertEqual(user.username, 'test01')
|
||||
self.assertEqual(user.homedir, '/home/test01')
|
||||
self.assertEqual(user.shell, '/bin/fooshell')
|
||||
self.assertIsNotNone(user.shadow)
|
||||
|
||||
|
||||
@override_settings(
|
||||
OSUSER_MINUID=10000,
|
||||
OSUSER_MINGID=10000,
|
||||
OSUSER_USERNAME_PREFIX="test",
|
||||
OSUSER_HOME_BASEPATH="/home",
|
||||
OSUSER_DEFAULT_SHELL="/bin/fooshell",
|
||||
OSUSER_MINUID=10000, OSUSER_MINGID=10000, OSUSER_USERNAME_PREFIX='test',
|
||||
OSUSER_HOME_BASEPATH='/home', OSUSER_DEFAULT_SHELL='/bin/fooshell'
|
||||
)
|
||||
class UserTest(TestCaseWithCeleryTasks):
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user("test")
|
||||
self.customer = Customer.objects.create_user('test')
|
||||
super(UserTest, self).setUp()
|
||||
|
||||
def test___str__(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
self.assertEqual(str(user), "test01 (10000)")
|
||||
self.assertEqual(str(user), 'test01 (10000)')
|
||||
|
||||
def test_set_password(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
self.assertFalse(sha512_crypt.verify("test", user.shadow.passwd))
|
||||
user.set_password("test")
|
||||
self.assertTrue(sha512_crypt.verify("test", user.shadow.passwd))
|
||||
self.assertFalse(sha512_crypt.verify('test', user.shadow.passwd))
|
||||
user.set_password('test')
|
||||
self.assertTrue(sha512_crypt.verify('test', user.shadow.passwd))
|
||||
|
||||
def test_save(self):
|
||||
user = User.objects.create_user(self.customer)
|
||||
|
@ -440,10 +400,8 @@ class UserTest(TestCaseWithCeleryTasks):
|
|||
self.assertEqual(len(taskres), 3)
|
||||
creators = [r.creator for r in taskres]
|
||||
for task in [
|
||||
"handle_group_created",
|
||||
"handle_user_created",
|
||||
"handle_user_password_set",
|
||||
]:
|
||||
'handle_group_created', 'handle_user_created',
|
||||
'handle_user_password_set']:
|
||||
self.assertIn(task, creators)
|
||||
|
||||
def test_delete_only_user(self):
|
||||
|
@ -453,38 +411,30 @@ class UserTest(TestCaseWithCeleryTasks):
|
|||
self.assertEqual(len(taskres), 6)
|
||||
creators = [r.creator for r in taskres]
|
||||
for task in [
|
||||
"handle_group_created",
|
||||
"handle_user_created",
|
||||
"handle_user_password_set",
|
||||
"handle_user_deleted",
|
||||
"handle_group_deleted",
|
||||
"handle_user_deleted",
|
||||
]:
|
||||
'handle_group_created', 'handle_user_created',
|
||||
'handle_user_password_set', 'handle_user_deleted',
|
||||
'handle_group_deleted', 'handle_user_deleted']:
|
||||
self.assertIn(task, creators)
|
||||
self.assertEqual(len(User.objects.all()), 0)
|
||||
|
||||
def test_delete_additional_groups(self):
|
||||
group1 = Group.objects.create(gid=2000, groupname="group1")
|
||||
group2 = Group.objects.create(gid=2001, groupname="group2")
|
||||
group1 = Group.objects.create(gid=2000, groupname='group1')
|
||||
group2 = Group.objects.create(gid=2001, groupname='group2')
|
||||
user = User.objects.create_user(self.customer)
|
||||
for group in [group1, group2]:
|
||||
# noinspection PyUnresolvedReferences
|
||||
user.additionalgroup_set.add(
|
||||
AdditionalGroup.objects.create(user=user, group=group)
|
||||
)
|
||||
AdditionalGroup.objects.create(user=user, group=group))
|
||||
TaskResult.objects.all().delete()
|
||||
user.delete()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 5)
|
||||
creators = [t.creator for t in taskres]
|
||||
for tcount, tcreator in [
|
||||
(2, "handle_user_removed_from_group"),
|
||||
(2, "handle_user_deleted"),
|
||||
(1, "handle_group_deleted"),
|
||||
]:
|
||||
(2, 'handle_user_removed_from_group'),
|
||||
(2, 'handle_user_deleted'),
|
||||
(1, 'handle_group_deleted')]:
|
||||
self.assertEqual(creators.count(tcreator), tcount)
|
||||
self.assertEqual(len(User.objects.all()), 0)
|
||||
# noinspection PyUnresolvedReferences
|
||||
self.assertEqual(len(AdditionalGroup.objects.all()), 0)
|
||||
|
||||
def test_is_sftp_user(self):
|
||||
|
@ -492,140 +442,138 @@ class UserTest(TestCaseWithCeleryTasks):
|
|||
self.assertFalse(user.is_sftp_user())
|
||||
|
||||
sftp_group = Group.objects.create(
|
||||
gid=2000, groupname=settings.OSUSER_SFTP_GROUP
|
||||
)
|
||||
# noinspection PyUnresolvedReferences
|
||||
gid=2000, groupname=settings.OSUSER_SFTP_GROUP)
|
||||
user.additionalgroup_set.add(
|
||||
AdditionalGroup.objects.create(user=user, group=sftp_group)
|
||||
)
|
||||
AdditionalGroup.objects.create(user=user, group=sftp_group))
|
||||
self.assertTrue(user.is_sftp_user())
|
||||
|
||||
|
||||
class SshPublicKeyManagerTest(TestCaseWithCeleryTasks):
|
||||
def test_parse_keytext_rfc4716_1(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_1_RFC4716)
|
||||
res = SshPublicKey.objects.parse_keytext(EXAMPLE_KEY_1_RFC4716)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[0], "ssh-rsa")
|
||||
self.assertEqual(res[0], 'ssh-rsa')
|
||||
self.assertEqual(
|
||||
res[2], '"1024-bit RSA, converted from OpenSSH by me@example.com"'
|
||||
)
|
||||
res[2], '"1024-bit RSA, converted from OpenSSH by me@example.com"')
|
||||
|
||||
def test_parse_keytext_rfc4716_2(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_2_RFC4716)
|
||||
res = SshPublicKey.objects.parse_keytext(EXAMPLE_KEY_2_RFC4716)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-dss")
|
||||
self.assertEqual(res[0], 'ssh-dss')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(
|
||||
res[2], "This is my public key for use on servers which I don't like."
|
||||
)
|
||||
res[2],
|
||||
"This is my public key for use on servers which I don't like.")
|
||||
|
||||
def test_parse_keytext_rfc4716_3(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_3_RFC4716)
|
||||
res = SshPublicKey.objects.parse_keytext(EXAMPLE_KEY_3_RFC4716)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-dss")
|
||||
self.assertEqual(res[0], 'ssh-dss')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[2], "DSA Public Key for use with MyIsp")
|
||||
|
||||
def test_parse_keytext_openssh(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_4_OPENSSH)
|
||||
res = SshPublicKey.objects.parse_keytext(EXAMPLE_KEY_4_OPENSSH)
|
||||
self.assertEquals(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-rsa")
|
||||
self.assertEqual(res[0], 'ssh-rsa')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[2], "")
|
||||
self.assertEqual(res[2], '')
|
||||
|
||||
def test_parse_keytext_invalid_multiline(self):
|
||||
with self.assertRaises(ValueError):
|
||||
SshPublicKey.objects.parse_key_text("\r\n".join(["xx"] * 10))
|
||||
SshPublicKey.objects.parse_keytext("\r\n".join(["xx"]*10))
|
||||
|
||||
def test_parse_keytext_empty_line(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_6_RFC4716_EMPTY_LINE)
|
||||
res = SshPublicKey.objects.parse_keytext(
|
||||
EXAMPLE_KEY_6_RFC4716_EMPTY_LINE)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-dss")
|
||||
self.assertEqual(res[0], 'ssh-dss')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[2], "DSA Public Key for use with MyIsp")
|
||||
|
||||
def test_parse_keytext_invalid_empty_rfc4716_header(self):
|
||||
with self.assertRaises(ValueError):
|
||||
SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_9_RFC4716_ONLY_HEADER)
|
||||
SshPublicKey.objects.parse_keytext(
|
||||
EXAMPLE_KEY_9_RFC4716_ONLY_HEADER)
|
||||
|
||||
def test_parse_keytext_no_comment(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_7_NO_COMMENT)
|
||||
res = SshPublicKey.objects.parse_keytext(
|
||||
EXAMPLE_KEY_7_NO_COMMENT)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-rsa")
|
||||
self.assertEqual(res[0], 'ssh-rsa')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[2], "")
|
||||
self.assertEqual(res[2], '')
|
||||
|
||||
def test_parse_keytext_multiline_comment(self):
|
||||
res = SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_5_RFC4716_MULTILINE)
|
||||
res = SshPublicKey.objects.parse_keytext(
|
||||
EXAMPLE_KEY_5_RFC4716_MULTILINE)
|
||||
self.assertEqual(len(res), 3)
|
||||
self.assertEqual(res[0], "ssh-dss")
|
||||
self.assertEqual(res[0], 'ssh-dss')
|
||||
self.assertGreater(len(res[1]), 40)
|
||||
self.assertEqual(res[2], "DSA Public Key for use with MyIsp")
|
||||
|
||||
def test_parse_keytext_invalid(self):
|
||||
with self.assertRaises(ValueError):
|
||||
SshPublicKey.objects.parse_key_text("invalid")
|
||||
SshPublicKey.objects.parse_keytext('invalid')
|
||||
|
||||
def test_parse_keytext_invalid_openssh(self):
|
||||
with self.assertRaises(ValueError):
|
||||
SshPublicKey.objects.parse_key_text(EXAMPLE_KEY_8_OPENSSH_BROKEN)
|
||||
SshPublicKey.objects.parse_keytext(EXAMPLE_KEY_8_OPENSSH_BROKEN)
|
||||
|
||||
def test_create_ssh_public_key(self):
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
user = User.objects.create_user(customer)
|
||||
key = SshPublicKey.objects.create_ssh_public_key(user, EXAMPLE_KEY_4_OPENSSH)
|
||||
key = SshPublicKey.objects.create_ssh_public_key(
|
||||
user, EXAMPLE_KEY_4_OPENSSH)
|
||||
self.assertIsInstance(key, SshPublicKey)
|
||||
self.assertEqual(key.user, user)
|
||||
self.assertEqual(key.algorithm, "ssh-rsa")
|
||||
self.assertEqual(key.algorithm, 'ssh-rsa')
|
||||
self.assertEqual(key.data, EXAMPLE_KEY_4_OPENSSH.split()[1])
|
||||
self.assertEqual(key.comment, "")
|
||||
self.assertEqual(key.comment, '')
|
||||
|
||||
|
||||
class SshPublicKeyTest(TestCaseWithCeleryTasks):
|
||||
def setUp(self):
|
||||
super(SshPublicKeyTest, self).setUp()
|
||||
customer = Customer.objects.create_user("test")
|
||||
customer = Customer.objects.create_user('test')
|
||||
self.user = User.objects.create_user(customer)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test__str__rfc4716(self):
|
||||
res = SshPublicKey.objects.create_ssh_public_key(
|
||||
self.user, EXAMPLE_KEY_3_RFC4716
|
||||
)
|
||||
self.maxDiff = None
|
||||
self.user, EXAMPLE_KEY_3_RFC4716)
|
||||
self.assertEqual(
|
||||
str(res),
|
||||
"ssh-dss AAAAB3NzaC1kc3MAAACBAPY8ZOHY2yFSJA6XYC9HRwNHxae"
|
||||
"hvx5wOJ0rzZdzoSOXxbETW6ToHv8D1UJ/z+zHo9Fiko5XybZnDIaBDHtblQ+Yp7St"
|
||||
"xyltHnXF1YLfKD1G4T6JYrdHYI14Om1eg9e4NnCRleaqoZPF3UGfZia6bXrGTQf3g"
|
||||
"Jq2e7Yisk/gF+1VAAAAFQDb8D5cvwHWTZDPfX0D2s9Rd7NBvQAAAIEAlN92+Bb7D4"
|
||||
"KLYk3IwRbXblwXdkPggA4pfdtW9vGfJ0/RHd+NjB4eo1D+0dix6tXwYGN7PKS5R/F"
|
||||
"XPNwxHPapcj9uL1Jn2AWQ2dsknf+i/FAAvioUPkmdMc0zuWoSOEsSNhVDtX3WdvVc"
|
||||
"GcBq9cetzrtOKWOocJmJ80qadxTRHtUAAACBAN7CY+KKv1gHpRzFwdQm7HK9bb1LA"
|
||||
"o2KwaoXnadFgeptNBQeSXG1vO+JsvphVMBJc9HSn24VYtYtsMu74qXviYjziVucWK"
|
||||
"jjKEb11juqnF0GDlB3VVmxHLmxnAz643WK42Z7dLM5sY29ouezv4Xz2PuMch5VGPP"
|
||||
"+CDqzCM4loWgV DSA Public Key for use with MyIsp",
|
||||
)
|
||||
str(res), 'ssh-dss AAAAB3NzaC1kc3MAAACBAPY8ZOHY2yFSJA6XYC9HRwNHxae'
|
||||
'hvx5wOJ0rzZdzoSOXxbETW6ToHv8D1UJ/z+zHo9Fiko5XybZnDIaBDHtblQ+Yp7St'
|
||||
'xyltHnXF1YLfKD1G4T6JYrdHYI14Om1eg9e4NnCRleaqoZPF3UGfZia6bXrGTQf3g'
|
||||
'Jq2e7Yisk/gF+1VAAAAFQDb8D5cvwHWTZDPfX0D2s9Rd7NBvQAAAIEAlN92+Bb7D4'
|
||||
'KLYk3IwRbXblwXdkPggA4pfdtW9vGfJ0/RHd+NjB4eo1D+0dix6tXwYGN7PKS5R/F'
|
||||
'XPNwxHPapcj9uL1Jn2AWQ2dsknf+i/FAAvioUPkmdMc0zuWoSOEsSNhVDtX3WdvVc'
|
||||
'GcBq9cetzrtOKWOocJmJ80qadxTRHtUAAACBAN7CY+KKv1gHpRzFwdQm7HK9bb1LA'
|
||||
'o2KwaoXnadFgeptNBQeSXG1vO+JsvphVMBJc9HSn24VYtYtsMu74qXviYjziVucWK'
|
||||
'jjKEb11juqnF0GDlB3VVmxHLmxnAz643WK42Z7dLM5sY29ouezv4Xz2PuMch5VGPP'
|
||||
'+CDqzCM4loWgV DSA Public Key for use with MyIsp')
|
||||
|
||||
def test__str__openssh(self):
|
||||
res = SshPublicKey.objects.create_ssh_public_key(
|
||||
self.user, EXAMPLE_KEY_4_OPENSSH
|
||||
)
|
||||
self.user, EXAMPLE_KEY_4_OPENSSH)
|
||||
self.assertEqual(str(res), EXAMPLE_KEY_4_OPENSSH)
|
||||
|
||||
def test_call_tasks_on_save(self):
|
||||
SshPublicKey.objects.create_ssh_public_key(self.user, EXAMPLE_KEY_4_OPENSSH)
|
||||
SshPublicKey.objects.create_ssh_public_key(
|
||||
self.user, EXAMPLE_KEY_4_OPENSSH)
|
||||
taskresults = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskresults), 1)
|
||||
self.assertEqual(taskresults[0].creator, "handle_ssh_keys_changed")
|
||||
self.assertEqual(
|
||||
taskresults[0].creator, 'handle_ssh_keys_changed')
|
||||
|
||||
def test_call_tasks_on_delete(self):
|
||||
key = SshPublicKey.objects.create_ssh_public_key(
|
||||
self.user, EXAMPLE_KEY_4_OPENSSH
|
||||
)
|
||||
self.user, EXAMPLE_KEY_4_OPENSSH)
|
||||
TaskResult.objects.all().delete()
|
||||
key.delete()
|
||||
taskresults = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskresults), 1)
|
||||
self.assertEqual(taskresults[0].creator, "handle_ssh_keys_changed")
|
||||
self.assertEqual(
|
||||
taskresults[0].creator, 'handle_ssh_keys_changed')
|
||||
|
|
|
@ -2,59 +2,66 @@
|
|||
This module provides tests for :py:mod:`osusers.views`.
|
||||
|
||||
"""
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
from unittest.mock import patch, MagicMock
|
||||
try:
|
||||
from unittest.mock import patch, MagicMock
|
||||
except ImportError:
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase, TransactionTestCase
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.urls import reverse
|
||||
|
||||
from hostingpackages.models import CustomerHostingPackage, HostingPackageTemplate
|
||||
from hostingpackages.models import (
|
||||
CustomerHostingPackage,
|
||||
HostingPackageTemplate,
|
||||
)
|
||||
|
||||
from osusers.models import SshPublicKey
|
||||
from osusers.views import AddSshPublicKey, DeleteSshPublicKey, EditSshPublicKeyComment
|
||||
from osusers.views import (
|
||||
AddSshPublicKey,
|
||||
DeleteSshPublicKey,
|
||||
EditSshPublicKeyComment,
|
||||
)
|
||||
|
||||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_EMAIL = "test@example.org"
|
||||
EXAMPLE_KEY = "".join(
|
||||
(
|
||||
"ssh-rsa ",
|
||||
"AAAAB3NzaC1yc2EAAAABIwAAAIEA1on8gxCGJJWSRT4uOrR13mUaUk0hRf4RzxSZ1zRb",
|
||||
"YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ",
|
||||
"5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE=",
|
||||
)
|
||||
)
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
TEST_EMAIL = 'test@example.org'
|
||||
EXAMPLE_KEY = "".join((
|
||||
"ssh-rsa ",
|
||||
"AAAAB3NzaC1yc2EAAAABIwAAAIEA1on8gxCGJJWSRT4uOrR13mUaUk0hRf4RzxSZ1zRb",
|
||||
"YYFw8pfGesIFoEuVth4HKyF8k1y4mRUnYHP1XNMNMJl1JcEArC2asV8sHf6zSPVffozZ",
|
||||
"5TT4SfsUu/iKy9lUcCfXzwre4WWZSXXcPff+EHtWshahu3WzBdnGxm5Xoi89zcE="
|
||||
))
|
||||
|
||||
|
||||
class HostingPackageAwareTestMixin(object):
|
||||
|
||||
# noinspection PyMethodMayBeStatic
|
||||
def _setup_hosting_package(self, customer):
|
||||
template = HostingPackageTemplate.objects.create(
|
||||
name="testpackagetemplate", mailboxcount=10, diskspace=1, diskspace_unit=0
|
||||
)
|
||||
name='testpackagetemplate', mailboxcount=10, diskspace=1,
|
||||
diskspace_unit=0)
|
||||
package = CustomerHostingPackage.objects.create_from_template(
|
||||
customer, template, "testpackage"
|
||||
)
|
||||
with patch("hostingpackages.models.settings") as hmsettings:
|
||||
customer, template, 'testpackage')
|
||||
with patch('hostingpackages.models.settings') as hmsettings:
|
||||
hmsettings.OSUSER_DEFAULT_GROUPS = []
|
||||
package.save()
|
||||
return package
|
||||
|
||||
|
||||
class AddSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
|
||||
def _get_url(self):
|
||||
return reverse("add_ssh_key", kwargs={"package": self.package.id})
|
||||
return reverse('add_ssh_key', kwargs={'package': self.package.id})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -66,75 +73,77 @@ class AddSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "osusers/sshpublickey_create.html")
|
||||
self.assertTemplateUsed(response, 'osusers/sshpublickey_create.html')
|
||||
|
||||
def test_get_form_kwargs(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = AddSshPublicKey(
|
||||
request=MagicMock(), kwargs={"package": str(self.package.pk)}
|
||||
)
|
||||
request=MagicMock(), kwargs={'package': str(self.package.pk)})
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertIn("osuser", response.context)
|
||||
self.assertEqual(response.context["osuser"], self.package.osuser.username)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertIn('osuser', response.context)
|
||||
self.assertEqual(
|
||||
response.context['osuser'], self.package.osuser.username)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(), data={"publickeytext": EXAMPLE_KEY}
|
||||
)
|
||||
self._get_url(),
|
||||
data={'publickeytext': EXAMPLE_KEY})
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(), follow=True, data={"publickeytext": EXAMPLE_KEY}
|
||||
)
|
||||
messages = list(response.context["messages"])
|
||||
self._get_url(), follow=True,
|
||||
data={'publickeytext': EXAMPLE_KEY})
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
"Successfully added new ssh-rsa SSH public key.".format(
|
||||
'Successfully added new ssh-rsa SSH public key.'.format(
|
||||
username=self.package.osuser.username
|
||||
),
|
||||
str(messages[0]),
|
||||
)
|
||||
), str(messages[0]))
|
||||
|
||||
|
||||
class DeleteSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
self.sshkey = SshPublicKey.objects.create(
|
||||
user=self.package.osuser, algorithm="good", data="key", comment="comment"
|
||||
)
|
||||
user=self.package.osuser, algorithm='good', data='key',
|
||||
comment='comment')
|
||||
|
||||
def _get_url(self):
|
||||
return reverse(
|
||||
"delete_ssh_key", kwargs={"package": self.package.id, "pk": self.sshkey.id}
|
||||
)
|
||||
'delete_ssh_key', kwargs={
|
||||
'package': self.package.id,
|
||||
'pk': self.sshkey.id
|
||||
})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -146,63 +155,71 @@ class DeleteSshPublicKeyTest(HostingPackageAwareTestMixin, TestCase):
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "osusers/sshpublickey_confirm_delete.html")
|
||||
self.assertTemplateUsed(
|
||||
response, 'osusers/sshpublickey_confirm_delete.html')
|
||||
|
||||
def test_get_queryset(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = DeleteSshPublicKey(
|
||||
request=MagicMock(),
|
||||
kwargs={"package": str(self.package.pk), "pk": str(self.sshkey.pk)},
|
||||
)
|
||||
request=MagicMock(), kwargs={
|
||||
'package': str(self.package.pk),
|
||||
'pk': str(self.sshkey.pk)
|
||||
})
|
||||
queryset = view.get_queryset()
|
||||
self.assertQuerysetEqual(queryset, [repr(self.sshkey)])
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
for key in ("hostingpackage", "customer", "osuser"):
|
||||
for key in ('hostingpackage', 'customer', 'osuser'):
|
||||
self.assertIn(key, response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertEqual(response.context["osuser"], self.package.osuser.username)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertEqual(
|
||||
response.context['osuser'], self.package.osuser.username)
|
||||
|
||||
def test_get_success_url(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(self._get_url(), data={"comment": "new comment"})
|
||||
self.assertRedirects(
|
||||
response, reverse("list_ssh_keys", kwargs={"package": self.package.id})
|
||||
)
|
||||
response = self.client.post(
|
||||
self._get_url(),
|
||||
data={'comment': 'new comment'})
|
||||
self.assertRedirects(response, reverse('list_ssh_keys', kwargs={
|
||||
'package': self.package.id}))
|
||||
|
||||
|
||||
class EditSshPublicKeyCommentTest(HostingPackageAwareTestMixin, TransactionTestCase):
|
||||
class EditSshPublicKeyCommentTest(
|
||||
HostingPackageAwareTestMixin, TransactionTestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
self.sshkey = SshPublicKey.objects.create(
|
||||
user=self.package.osuser, algorithm="good", data="key", comment="comment"
|
||||
)
|
||||
user=self.package.osuser, algorithm='good', data='key',
|
||||
comment='comment')
|
||||
|
||||
def _get_url(self):
|
||||
return reverse(
|
||||
"edit_ssh_key_comment",
|
||||
kwargs={"package": self.package.id, "pk": self.sshkey.id},
|
||||
)
|
||||
'edit_ssh_key_comment', kwargs={
|
||||
'package': self.package.id,
|
||||
'pk': self.sshkey.id
|
||||
})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -214,67 +231,74 @@ class EditSshPublicKeyCommentTest(HostingPackageAwareTestMixin, TransactionTestC
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "osusers/sshpublickey_edit_comment.html")
|
||||
self.assertTemplateUsed(
|
||||
response, 'osusers/sshpublickey_edit_comment.html')
|
||||
|
||||
def test_get_queryset(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = EditSshPublicKeyComment(
|
||||
request=MagicMock(),
|
||||
kwargs={"package": str(self.package.pk), "pk": str(self.sshkey.pk)},
|
||||
)
|
||||
request=MagicMock(), kwargs={
|
||||
'package': str(self.package.pk),
|
||||
'pk': str(self.sshkey.pk)
|
||||
})
|
||||
queryset = view.get_queryset()
|
||||
self.assertQuerysetEqual(queryset, [repr(self.sshkey)])
|
||||
|
||||
def test_get_form_kwargs(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = EditSshPublicKeyComment(
|
||||
request=MagicMock(),
|
||||
kwargs={"package": str(self.package.pk), "pk": str(self.sshkey.pk)},
|
||||
)
|
||||
request=MagicMock(), kwargs={
|
||||
'package': str(self.package.pk),
|
||||
'pk': str(self.sshkey.pk)
|
||||
})
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
for key in ("hostingpackage", "customer", "osuser"):
|
||||
for key in ('hostingpackage', 'customer', 'osuser'):
|
||||
self.assertIn(key, response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertEqual(response.context["osuser"], self.package.osuser.username)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertEqual(
|
||||
response.context['osuser'], self.package.osuser.username)
|
||||
|
||||
def test_get_success_url(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(self._get_url(), data={"comment": "new comment"})
|
||||
self.assertRedirects(
|
||||
response, reverse("list_ssh_keys", kwargs={"package": self.package.id})
|
||||
)
|
||||
response = self.client.post(
|
||||
self._get_url(),
|
||||
data={'comment': 'new comment'})
|
||||
self.assertRedirects(response, reverse('list_ssh_keys', kwargs={
|
||||
'package': self.package.id}))
|
||||
|
||||
|
||||
class ListSshPublicKeysTest(HostingPackageAwareTestMixin, TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
|
||||
def _get_url(self):
|
||||
return reverse("list_ssh_keys", kwargs={"package": self.package.id})
|
||||
return reverse('list_ssh_keys', kwargs={'package': self.package.id})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -286,43 +310,45 @@ class ListSshPublicKeysTest(HostingPackageAwareTestMixin, TestCase):
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "osusers/sshpublickey_list.html")
|
||||
self.assertTemplateUsed(response, 'osusers/sshpublickey_list.html')
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
for key in ("hostingpackage", "customer", "osuser"):
|
||||
for key in ('hostingpackage', 'customer', 'osuser'):
|
||||
self.assertIn(key, response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertEqual(response.context["osuser"], self.package.osuser.username)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertEqual(
|
||||
response.context['osuser'], self.package.osuser.username)
|
||||
|
||||
|
||||
class SetOsUserPasswordTest(HostingPackageAwareTestMixin, TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
|
||||
def _get_url(self):
|
||||
return reverse(
|
||||
"set_osuser_password", kwargs={"slug": self.package.osuser.username}
|
||||
)
|
||||
return reverse('set_osuser_password', kwargs={
|
||||
'slug': self.package.osuser.username})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -334,48 +360,45 @@ class SetOsUserPasswordTest(HostingPackageAwareTestMixin, TestCase):
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "osusers/user_setpassword.html")
|
||||
self.assertTemplateUsed(response, 'osusers/user_setpassword.html')
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(),
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
data={'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(),
|
||||
follow=True,
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
messages = list(response.context["messages"])
|
||||
self._get_url(), follow=True,
|
||||
data={'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
"New password for {username} has been set successfully.".format(
|
||||
'New password for {username} has been set successfully.'.format(
|
||||
username=self.package.osuser.username
|
||||
),
|
||||
str(messages[0]),
|
||||
)
|
||||
), str(messages[0]))
|
||||
|
|
|
@ -9,7 +9,7 @@ source = gnuviechadmin,contact_form,dashboard,domains,gvawebcore,managemails,osu
|
|||
branch = True
|
||||
|
||||
[coverage:report]
|
||||
omit = */migrations/*,*/tests/*.py,*/tests.py,gnuviechadmin/settings.py
|
||||
omit = */migrations/*,*/tests/*.py,*/tests.py,gnuviechadmin/settings/local.py,gnuviechadmin/settings/production.py
|
||||
show_missing = True
|
||||
|
||||
[coverage:html]
|
||||
|
|
|
@ -4,32 +4,39 @@ This module provides tests for the
|
|||
command.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from unittest.mock import MagicMock, patch
|
||||
try:
|
||||
from unittest.mock import patch, MagicMock
|
||||
except ImportError:
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.test import TestCase
|
||||
|
||||
from taskresults.management.commands.fetch_taskresults import Command
|
||||
from taskresults.models import TaskResult
|
||||
|
||||
TEST_TASK_UUID = "3120f6a8-2665-4fa3-a785-79efd28bfe92"
|
||||
TEST_TASK_NAME = "test.task"
|
||||
TEST_TASK_RESULT = "4ll y0ur b453 4r3 b3l0ng t0 u5"
|
||||
from taskresults.management.commands.fetch_taskresults import Command
|
||||
|
||||
|
||||
@patch("taskresults.models.app.AsyncResult")
|
||||
TEST_TASK_UUID = '3120f6a8-2665-4fa3-a785-79efd28bfe92'
|
||||
TEST_TASK_NAME = 'test.task'
|
||||
TEST_TASK_RESULT = '4ll y0ur b453 4r3 b3l0ng t0 u5'
|
||||
|
||||
|
||||
@patch('taskresults.models.app.AsyncResult')
|
||||
class FetchTaskResultsCommandTest(TestCase):
|
||||
|
||||
def test_handle_unfinished(self, asyncresult):
|
||||
resultmock = MagicMock(task_id=TEST_TASK_UUID)
|
||||
sigmock = MagicMock()
|
||||
sigmock.apply_async.return_value = resultmock
|
||||
tr = TaskResult.objects.create_task_result(TEST_TASK_NAME, sigmock)
|
||||
self.assertFalse(tr.finished)
|
||||
self.assertEqual(tr.result, "")
|
||||
self.assertEqual(tr.state, "")
|
||||
self.assertEqual(tr.result, '')
|
||||
self.assertEqual(tr.state, '')
|
||||
|
||||
aresult = asyncresult.return_value
|
||||
aresult.state = "PENDING"
|
||||
aresult.state = 'PENDING'
|
||||
aresult.ready.return_value = False
|
||||
|
||||
Command().handle()
|
||||
|
@ -38,8 +45,8 @@ class FetchTaskResultsCommandTest(TestCase):
|
|||
self.assertTrue(asyncresult.called_with(TEST_TASK_UUID))
|
||||
self.assertTrue(aresult.ready.called_with())
|
||||
self.assertFalse(tr.finished)
|
||||
self.assertEqual(tr.result, "")
|
||||
self.assertEqual(tr.state, "PENDING")
|
||||
self.assertEqual(tr.result, '')
|
||||
self.assertEqual(tr.state, 'PENDING')
|
||||
|
||||
def test_handle_finished(self, asyncresult):
|
||||
resultmock = MagicMock(task_id=TEST_TASK_UUID)
|
||||
|
@ -47,11 +54,11 @@ class FetchTaskResultsCommandTest(TestCase):
|
|||
sigmock.apply_async.return_value = resultmock
|
||||
tr = TaskResult.objects.create_task_result(TEST_TASK_NAME, sigmock)
|
||||
self.assertFalse(tr.finished)
|
||||
self.assertEqual(tr.result, "")
|
||||
self.assertEqual(tr.state, "")
|
||||
self.assertEqual(tr.result, '')
|
||||
self.assertEqual(tr.state, '')
|
||||
|
||||
aresult = asyncresult.return_value
|
||||
aresult.state = "SUCCESS"
|
||||
aresult.state = 'SUCCESS'
|
||||
aresult.ready.return_value = True
|
||||
aresult.get.return_value = TEST_TASK_RESULT
|
||||
|
||||
|
@ -63,4 +70,4 @@ class FetchTaskResultsCommandTest(TestCase):
|
|||
self.assertTrue(aresult.get.called_with())
|
||||
self.assertTrue(tr.finished)
|
||||
self.assertEqual(tr.result, TEST_TASK_RESULT)
|
||||
self.assertEqual(tr.state, "SUCCESS")
|
||||
self.assertEqual(tr.state, 'SUCCESS')
|
||||
|
|
|
@ -2,19 +2,25 @@
|
|||
This module provides tests for :py:mod:`taskresults.models`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, patch
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
try:
|
||||
from unittest.mock import patch, MagicMock
|
||||
except ImportError:
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.test import TestCase
|
||||
|
||||
from taskresults.models import TaskResult
|
||||
|
||||
TEST_TASK_UUID = "3120f6a8-2665-4fa3-a785-79efd28bfe92"
|
||||
TEST_TASK_NAME = "test.task"
|
||||
TEST_TASK_RESULT = "4ll y0ur b453 4r3 b3l0ng t0 u5"
|
||||
|
||||
TEST_TASK_UUID = '3120f6a8-2665-4fa3-a785-79efd28bfe92'
|
||||
TEST_TASK_NAME = 'test.task'
|
||||
TEST_TASK_RESULT = '4ll y0ur b453 4r3 b3l0ng t0 u5'
|
||||
|
||||
|
||||
class TaskResultTest(TestCase):
|
||||
@patch("taskresults.models.app.AsyncResult")
|
||||
@patch('taskresults.models.app.AsyncResult')
|
||||
def test_update_taskstatus_unfinished(self, asyncresult):
|
||||
resultmock = MagicMock(task_id=TEST_TASK_UUID)
|
||||
sigmock = MagicMock()
|
||||
|
@ -22,13 +28,13 @@ class TaskResultTest(TestCase):
|
|||
tr = TaskResult.objects.create_task_result(TEST_TASK_NAME, sigmock)
|
||||
self.assertFalse(tr.finished)
|
||||
mymock = asyncresult.return_value
|
||||
mymock.state = "PENDING"
|
||||
mymock.state = 'PENDING'
|
||||
mymock.ready.return_value = False
|
||||
tr.fetch_result()
|
||||
mymock.get.assert_not_called()
|
||||
self.assertFalse(tr.finished)
|
||||
|
||||
@patch("taskresults.models.app.AsyncResult")
|
||||
@patch('taskresults.models.app.AsyncResult')
|
||||
def test_update_taskstatus_finished(self, asyncresult):
|
||||
resultmock = MagicMock(task_id=TEST_TASK_UUID)
|
||||
sigmock = MagicMock()
|
||||
|
@ -37,7 +43,7 @@ class TaskResultTest(TestCase):
|
|||
tr = TaskResult.objects.create_task_result(TEST_TASK_NAME, sigmock)
|
||||
self.assertFalse(tr.finished)
|
||||
aresult = asyncresult.return_value
|
||||
aresult.state = "SUCCESS"
|
||||
aresult.state = 'SUCCESS'
|
||||
aresult.ready.return_value = True
|
||||
aresult.get.return_value = TEST_TASK_RESULT
|
||||
tr.fetch_result()
|
||||
|
@ -55,15 +61,11 @@ class TaskResultTest(TestCase):
|
|||
sigmock = MagicMock()
|
||||
sigmock.apply_async.return_value = resultmock
|
||||
tr = TaskResult.objects.create_task_result(TEST_TASK_NAME, sigmock)
|
||||
self.assertEqual(
|
||||
str(tr),
|
||||
"{name} ({taskid}): no".format(name=TEST_TASK_NAME, taskid=TEST_TASK_UUID),
|
||||
)
|
||||
self.assertEqual(str(tr), "{name} ({taskid}): no".format(
|
||||
name=TEST_TASK_NAME, taskid=TEST_TASK_UUID))
|
||||
tr.finished = True
|
||||
self.assertEqual(
|
||||
str(tr),
|
||||
"{name} ({taskid}): yes".format(name=TEST_TASK_NAME, taskid=TEST_TASK_UUID),
|
||||
)
|
||||
self.assertEqual(str(tr), "{name} ({taskid}): yes".format(
|
||||
name=TEST_TASK_NAME, taskid=TEST_TASK_UUID))
|
||||
|
||||
|
||||
TEST_RESULT = MagicMock()
|
||||
|
|
|
@ -2,33 +2,35 @@
|
|||
This module provides tests for :py:mod:`userdbs.admin`.
|
||||
|
||||
"""
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
from __future__ import absolute_import
|
||||
|
||||
from django.contrib.admin import AdminSite
|
||||
from django.test import TestCase
|
||||
|
||||
from userdbs.admin import (
|
||||
DatabaseUserAdmin,
|
||||
DatabaseUserCreationForm,
|
||||
UserDatabaseAdmin,
|
||||
UserDatabaseCreationForm,
|
||||
)
|
||||
from userdbs.admin import (DatabaseUserAdmin, DatabaseUserCreationForm,
|
||||
UserDatabaseAdmin, UserDatabaseCreationForm)
|
||||
from userdbs.models import DB_TYPES, DatabaseUser, UserDatabase
|
||||
|
||||
try:
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
except ImportError:
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
|
||||
class DatabaseUserCreationFormTest(TestCase):
|
||||
@patch("userdbs.admin.DatabaseUser.objects.create_database_user")
|
||||
|
||||
@patch('userdbs.admin.DatabaseUser.objects.create_database_user')
|
||||
def test_save(self, create_database_user):
|
||||
create_database_user.return_value = Mock()
|
||||
form = DatabaseUserCreationForm()
|
||||
mockuser = Mock(name="osuser")
|
||||
form.cleaned_data = {"osuser": mockuser, "db_type": DB_TYPES.pgsql}
|
||||
mockuser = Mock(name='osuser')
|
||||
form.cleaned_data = {
|
||||
'osuser': mockuser,
|
||||
'db_type': DB_TYPES.pgsql
|
||||
}
|
||||
retval = form.save()
|
||||
self.assertTrue(
|
||||
create_database_user.called_with(
|
||||
osuser=mockuser, db_type=DB_TYPES.pgsql, commit=True
|
||||
)
|
||||
)
|
||||
self.assertTrue(create_database_user.called_with(
|
||||
osuser=mockuser, db_type=DB_TYPES.pgsql, commit=True))
|
||||
self.assertEqual(retval, create_database_user.return_value)
|
||||
|
||||
def test_save_m2m_returns_none(self):
|
||||
|
@ -37,14 +39,16 @@ class DatabaseUserCreationFormTest(TestCase):
|
|||
|
||||
|
||||
class UserDatabaseCreationFormTest(TestCase):
|
||||
@patch("userdbs.admin.UserDatabase.objects.create_userdatabase")
|
||||
|
||||
@patch('userdbs.admin.UserDatabase.objects.create_userdatabase')
|
||||
def test_save(self, create_userdatabase):
|
||||
create_userdatabase.return_value = Mock()
|
||||
form = UserDatabaseCreationForm()
|
||||
mockuser = Mock(name="mockuser")
|
||||
form.cleaned_data = {"db_user": mockuser}
|
||||
mockuser = Mock(name='mockuser')
|
||||
form.cleaned_data = {'db_user': mockuser}
|
||||
retval = form.save()
|
||||
self.assertTrue(create_userdatabase.called_with(db_user=mockuser, commit=True))
|
||||
self.assertTrue(create_userdatabase.called_with(
|
||||
db_user=mockuser, commit=True))
|
||||
self.assertEqual(retval, create_userdatabase.return_value)
|
||||
|
||||
def test_save_m2m_returns_none(self):
|
||||
|
@ -53,96 +57,116 @@ class UserDatabaseCreationFormTest(TestCase):
|
|||
|
||||
|
||||
class DatabaseUserAdminTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.dbuadmin = DatabaseUserAdmin(DatabaseUser, site)
|
||||
super(DatabaseUserAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_with_instance(self):
|
||||
form = self.dbuadmin.get_form(Mock(name="request"), obj=Mock(name="dbuser"))
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "name", "db_type"])
|
||||
form = self.dbuadmin.get_form(
|
||||
Mock(name='request'), obj=Mock(name='dbuser'))
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'name', 'db_type']
|
||||
)
|
||||
|
||||
def test_get_form_without_instance(self):
|
||||
form = self.dbuadmin.get_form(Mock(name="request"))
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "db_type"])
|
||||
form = self.dbuadmin.get_form(Mock(name='request'))
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'db_type']
|
||||
)
|
||||
|
||||
def test_get_readonly_fields_with_instance(self):
|
||||
fields = self.dbuadmin.get_readonly_fields(
|
||||
Mock(name="request"), obj=Mock(name="dbuser")
|
||||
)
|
||||
self.assertEqual(fields, ["osuser", "name", "db_type"])
|
||||
Mock(name='request'), obj=Mock(name='dbuser'))
|
||||
self.assertEqual(
|
||||
fields, ['osuser', 'name', 'db_type'])
|
||||
|
||||
def test_get_readonly_fields_without_instance(self):
|
||||
fields = self.dbuadmin.get_readonly_fields(Mock(name="request"))
|
||||
fields = self.dbuadmin.get_readonly_fields(
|
||||
Mock(name='request'))
|
||||
self.assertEqual(fields, [])
|
||||
|
||||
def test_save_model_change(self):
|
||||
objmock = Mock()
|
||||
self.dbuadmin.save_model(Mock(name="request"), objmock, Mock(), True)
|
||||
self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), True)
|
||||
self.assertTrue(objmock.create_in_database.not_called())
|
||||
|
||||
def test_save_model_no_change(self):
|
||||
objmock = Mock()
|
||||
self.dbuadmin.save_model(Mock(name="request"), objmock, Mock(), False)
|
||||
self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), False)
|
||||
self.assertTrue(objmock.create_in_database.called_with())
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
usermock = Mock()
|
||||
selected = Mock()
|
||||
selected.all.return_value = [usermock]
|
||||
self.dbuadmin.perform_delete_selected(Mock(name="request"), selected)
|
||||
self.dbuadmin.perform_delete_selected(Mock(name='request'), selected)
|
||||
self.assertTrue(selected.all.called_with())
|
||||
self.assertTrue(usermock.delete.called_with())
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.dbuadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.dbuadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.dbuadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.dbuadmin.get_actions(requestmock))
|
||||
|
||||
|
||||
class UserDatabaseAdminTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.udbadmin = UserDatabaseAdmin(UserDatabase, site)
|
||||
super(UserDatabaseAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_with_instance(self):
|
||||
form = self.udbadmin.get_form(Mock(name="request"), obj=Mock(name="userdb"))
|
||||
self.assertEqual(form.Meta.fields, ["db_name", "db_user"])
|
||||
form = self.udbadmin.get_form(
|
||||
Mock(name='request'), obj=Mock(name='userdb'))
|
||||
self.assertEqual(form.Meta.fields, ['db_name', 'db_user'])
|
||||
|
||||
def test_get_form_without_instance(self):
|
||||
form = self.udbadmin.get_form(Mock(name="request"))
|
||||
self.assertEqual(form.Meta.fields, ["db_user"])
|
||||
form = self.udbadmin.get_form(Mock(name='request'))
|
||||
self.assertEqual(form.Meta.fields, ['db_user'])
|
||||
|
||||
def test_get_readonly_fields_with_instance(self):
|
||||
fields = self.udbadmin.get_readonly_fields(
|
||||
Mock(name="request"), obj=Mock(name="userdb")
|
||||
)
|
||||
self.assertEqual(fields, ["db_name", "db_user"])
|
||||
Mock(name='request'), obj=Mock(name='userdb'))
|
||||
self.assertEqual(
|
||||
fields, ['db_name', 'db_user'])
|
||||
|
||||
def test_get_readonly_fields_without_instance(self):
|
||||
fields = self.udbadmin.get_readonly_fields(Mock(name="request"))
|
||||
fields = self.udbadmin.get_readonly_fields(
|
||||
Mock(name='request'))
|
||||
self.assertEqual(fields, [])
|
||||
|
||||
def test_save_model_change(self):
|
||||
objmock = Mock()
|
||||
self.udbadmin.save_model(Mock(name="request"), objmock, Mock(), True)
|
||||
self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), True)
|
||||
self.assertTrue(objmock.create_in_database.not_called())
|
||||
|
||||
def test_save_model_no_change(self):
|
||||
objmock = Mock()
|
||||
self.udbadmin.save_model(Mock(name="request"), objmock, Mock(), False)
|
||||
self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), False)
|
||||
self.assertTrue(objmock.create_in_database.called_with())
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
userdbmock = Mock()
|
||||
selected = Mock()
|
||||
selected.all.return_value = [userdbmock]
|
||||
self.udbadmin.perform_delete_selected(Mock(name="request"), selected)
|
||||
self.udbadmin.perform_delete_selected(Mock(name='request'), selected)
|
||||
self.assertTrue(selected.all.called_with())
|
||||
self.assertTrue(userdbmock.delete.called_with())
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.udbadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.udbadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.udbadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.udbadmin.get_actions(requestmock))
|
||||
|
|
|
@ -2,15 +2,20 @@
|
|||
This module provides tests for :py:mod:`userdbs.forms`.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django import forms
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from userdbs.forms import AddUserDatabaseForm, ChangeDatabaseUserPasswordForm
|
||||
from userdbs.models import DB_TYPES
|
||||
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
try:
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
except ImportError:
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
|
||||
Customer = get_user_model()
|
||||
|
@ -28,68 +33,66 @@ class AddUserDatabaseFormTest(TestCase):
|
|||
def test_constructor_needs_hostingpackage(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
AddUserDatabaseForm(instance=Mock())
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
|
||||
def test_constructor_needs_dbtypes(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
AddUserDatabaseForm(instance=Mock(), hostingpackage=Mock())
|
||||
self.assertEqual(ke.exception.args[0], "dbtypes")
|
||||
self.assertEqual(ke.exception.args[0], 'dbtypes')
|
||||
|
||||
def test_constructor_one_dbtype(self):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql])]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
self.assertIn("db_type", form.fields)
|
||||
self.assertEqual(form.fields["db_type"].choices, dbtypes)
|
||||
self.assertTrue(isinstance(form.fields["db_type"].widget, forms.HiddenInput))
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_userdatabase", kwargs={"package": self.hostingpackage.id}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
self.assertIn('db_type', form.fields)
|
||||
self.assertEqual(form.fields['db_type'].choices, dbtypes)
|
||||
self.assertTrue(isinstance(
|
||||
form.fields['db_type'].widget,
|
||||
forms.HiddenInput))
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_userdatabase', kwargs={'package': self.hostingpackage.id}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
def test_constructor_multiple_dbtypes(self):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [
|
||||
(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql])
|
||||
]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
self.assertIn("db_type", form.fields)
|
||||
self.assertEqual(form.fields["db_type"].choices, dbtypes)
|
||||
self.assertTrue(isinstance(form.fields["db_type"].widget, forms.RadioSelect))
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_userdatabase", kwargs={"package": self.hostingpackage.id}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
self.assertIn('db_type', form.fields)
|
||||
self.assertEqual(form.fields['db_type'].choices, dbtypes)
|
||||
self.assertTrue(isinstance(
|
||||
form.fields['db_type'].widget,
|
||||
forms.RadioSelect))
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_userdatabase', kwargs={'package': self.hostingpackage.id}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
@patch("userdbs.forms.UserDatabase.objects.create_userdatabase_with_user")
|
||||
@patch('userdbs.forms.UserDatabase.objects.create_userdatabase_with_user')
|
||||
def test_save(self, create_userdatabase_with_user):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [
|
||||
(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql])
|
||||
]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
form.cleaned_data = {"db_type": DB_TYPES.pgsql, "password1": "secret"}
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
form.cleaned_data = {
|
||||
'db_type': DB_TYPES.pgsql,
|
||||
'password1': 'secret',
|
||||
}
|
||||
form.save()
|
||||
self.assertTrue(
|
||||
create_userdatabase_with_user.called_with(
|
||||
DB_TYPES.pgsql,
|
||||
self.hostingpackage.osuser,
|
||||
password="secret",
|
||||
commit=True,
|
||||
)
|
||||
)
|
||||
self.assertTrue(create_userdatabase_with_user.called_with(
|
||||
DB_TYPES.pgsql, self.hostingpackage.osuser,
|
||||
password='secret', commit=True))
|
||||
|
||||
|
||||
class ChangeDatabaseUserPasswordFormTest(TestCase):
|
||||
|
@ -104,31 +107,29 @@ class ChangeDatabaseUserPasswordFormTest(TestCase):
|
|||
def test_constructor_needs_hostingpackage(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
ChangeDatabaseUserPasswordForm(instance=Mock())
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
|
||||
def test_constructor(self):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
instance.name = "test"
|
||||
instance.name = 'test'
|
||||
form = ChangeDatabaseUserPasswordForm(
|
||||
instance=instance, hostingpackage=self.hostingpackage
|
||||
)
|
||||
self.assertIn("password1", form.fields)
|
||||
self.assertIn("password2", form.fields)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("change_dbuser_password", kwargs={"slug": "test", "package": 42}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
instance=instance, hostingpackage=self.hostingpackage)
|
||||
self.assertIn('password1', form.fields)
|
||||
self.assertIn('password2', form.fields)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'change_dbuser_password', kwargs={
|
||||
'slug': 'test', 'package': 42
|
||||
}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
|
||||
def test_save(self):
|
||||
instance = MagicMock()
|
||||
instance.name = "test"
|
||||
instance.name = 'test'
|
||||
self._setup_hostingpackage()
|
||||
form = ChangeDatabaseUserPasswordForm(
|
||||
instance=instance, hostingpackage=self.hostingpackage
|
||||
)
|
||||
form.cleaned_data = {"password1": "secret"}
|
||||
instance=instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {'password1': 'secret'}
|
||||
form.save()
|
||||
self.assertTrue(instance.set_password.called_with("secret"))
|
||||
self.assertTrue(instance.set_password.called_with('secret'))
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
This module provides tests for :py:mod:`userdbs.models`.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
|
@ -14,7 +16,9 @@ Customer = get_user_model()
|
|||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class TestCaseWithCeleryTasks(TestCase):
|
||||
pass
|
||||
|
@ -25,85 +29,93 @@ class DatabaseUserManagerTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.DatabaseUserManager`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test_create_database_user_with_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql, "testname", "secret"
|
||||
)
|
||||
self.assertEqual(dbu.name, "testname")
|
||||
self.osuser, DB_TYPES.pgsql, 'testname', 'secret')
|
||||
self.assertEqual(dbu.name, 'testname')
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
|
||||
def test_create_database_user_with_name_no_commit(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql, "testname", "secret", False
|
||||
)
|
||||
self.assertEqual(dbu.name, "testname")
|
||||
self.osuser, DB_TYPES.pgsql, 'testname', 'secret', False)
|
||||
self.assertEqual(dbu.name, 'testname')
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_create_database_user_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.pgsql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
|
||||
def test_create_database_user_multiple_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db02".format(user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db02'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql user creation')
|
||||
|
||||
def test_create_database_user_multiple_gap_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db02".format(user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db02'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
DatabaseUser.objects.get(
|
||||
name="{user}db01".format(user=self.osuser.username)
|
||||
).delete()
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
name='{user}db01'.format(user=self.osuser.username)).delete()
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 4)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[2].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[2].notes, "mysql user deletion")
|
||||
self.assertEqual(taskres[3].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[3].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[2].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'mysql user deletion')
|
||||
self.assertEqual(taskres[3].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[3].notes, 'mysql user creation')
|
||||
|
||||
|
||||
class DatabaseUserTest(TestCaseWithCeleryTasks):
|
||||
|
@ -111,43 +123,41 @@ class DatabaseUserTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.DatabaseUser`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
self.dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql
|
||||
)
|
||||
self.osuser, DB_TYPES.pgsql)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test___str__(self):
|
||||
self.assertEqual(
|
||||
str(self.dbu),
|
||||
"{user}db01 (PostgreSQL for {user})".format(user=self.osuser.username),
|
||||
)
|
||||
'{user}db01 (PostgreSQL for {user})'.format(
|
||||
user=self.osuser.username))
|
||||
|
||||
def test_set_password_pgsql(self):
|
||||
self.dbu.set_password("secret")
|
||||
self.dbu.set_password('secret')
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_password_set")
|
||||
self.assertEqual(taskres[0].notes, "pgsql password change")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_password_set')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql password change')
|
||||
|
||||
def test_set_password_mysql(self):
|
||||
self.dbu.db_type = DB_TYPES.mysql
|
||||
self.dbu.save()
|
||||
self.dbu.set_password("secret")
|
||||
self.dbu.set_password('secret')
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_password_set")
|
||||
self.assertEqual(taskres[0].notes, "mysql password change")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_password_set')
|
||||
self.assertEqual(taskres[0].notes, 'mysql password change')
|
||||
|
||||
def test_delete_no_dbs(self):
|
||||
self.dbu.delete()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user deletion")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user deletion')
|
||||
|
||||
def test_delete_with_dbs(self):
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
|
@ -156,12 +166,12 @@ class DatabaseUserTest(TestCaseWithCeleryTasks):
|
|||
self.assertFalse(UserDatabase.objects.filter(id=dbid).exists())
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 3)
|
||||
self.assertEqual(taskres[0].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql database creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_deleted")
|
||||
self.assertEqual(taskres[1].notes, "pgsql database deletion")
|
||||
self.assertEqual(taskres[2].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[2].notes, "pgsql user deletion")
|
||||
self.assertEqual(taskres[0].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql database creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_deleted')
|
||||
self.assertEqual(taskres[1].notes, 'pgsql database deletion')
|
||||
self.assertEqual(taskres[2].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'pgsql user deletion')
|
||||
|
||||
|
||||
class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
||||
|
@ -169,52 +179,50 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.UserDatabaseManager`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def _create_database_user(self, dbtype):
|
||||
self.dbu = DatabaseUser.objects.create_database_user(self.osuser, dbtype)
|
||||
self.dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, dbtype)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test_create_userdatabase_with_user_mysql(self):
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.mysql, self.osuser
|
||||
)
|
||||
self.assertEqual(db.db_name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(
|
||||
db.db_user.name, "{user}db01".format(user=self.osuser.username)
|
||||
)
|
||||
DB_TYPES.mysql, self.osuser)
|
||||
self.assertEqual(db.db_name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(db.db_user.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql database creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql database creation')
|
||||
|
||||
def test_create_userdatabase_with_user_pgsql(self):
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.pgsql, self.osuser
|
||||
)
|
||||
self.assertEqual(db.db_name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(
|
||||
db.db_user.name, "{user}db01".format(user=self.osuser.username)
|
||||
)
|
||||
DB_TYPES.pgsql, self.osuser)
|
||||
self.assertEqual(db.db_name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(db.db_user.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[1].notes, "pgsql database creation")
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[1].notes, 'pgsql database creation')
|
||||
|
||||
def test_create_userdatabase_given_name_no_new_write(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name="test")
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name='test')
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(db.db_name, "test")
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
TaskResult.objects.all().delete()
|
||||
db.save()
|
||||
taskres = TaskResult.objects.all()
|
||||
|
@ -222,11 +230,11 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
|
||||
def test_create_userdatabase_given_name(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name="test")
|
||||
self.assertEqual(db.db_name, "test")
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name='test')
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(db.db_name, "test")
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
|
||||
def test_create_userdatabase_generate_name_no_commit(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
|
@ -244,19 +252,19 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, self.dbu.name)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
|
||||
def test_create_userdatabase_multiple_gap_generate_name(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, self.dbu.name)
|
||||
dbx = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(dbx.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
self.assertEqual(dbx.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, "{user}_03".format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, '{user}_03'.format(user=self.dbu.name))
|
||||
dbx.delete()
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
|
||||
|
||||
class UserDatabaseTest(TestCaseWithCeleryTasks):
|
||||
|
@ -264,23 +272,24 @@ class UserDatabaseTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.UserDabase`.
|
||||
|
||||
"""
|
||||
|
||||
def test___str__(self):
|
||||
customer = Customer.objects.create_user(username="testcustomer")
|
||||
customer = Customer.objects.create_user(username='testcustomer')
|
||||
osuser = User.objects.create_user(customer=customer)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(DB_TYPES.pgsql, osuser)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.pgsql, osuser)
|
||||
self.assertEqual(
|
||||
str(db),
|
||||
"{user}db01 ({dbuser})".format(user=osuser.username, dbuser=db.db_user),
|
||||
)
|
||||
'{user}db01 ({dbuser})'.format(
|
||||
user=osuser.username, dbuser=db.db_user))
|
||||
|
||||
def test_delete_mysql_db(self):
|
||||
customer = Customer.objects.create_user(username="testcustomer")
|
||||
customer = Customer.objects.create_user(username='testcustomer')
|
||||
osuser = User.objects.create_user(customer=customer)
|
||||
TaskResult.objects.all().delete()
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(DB_TYPES.mysql, osuser)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.mysql, osuser)
|
||||
db.delete()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 3)
|
||||
self.assertEqual(taskres[2].creator, "handle_userdb_deleted")
|
||||
self.assertEqual(taskres[2].notes, "mysql database deletion")
|
||||
self.assertEqual(taskres[2].creator, 'handle_userdb_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'mysql database deletion')
|
||||
|
|
|
@ -4,60 +4,63 @@ This module contains explicit tests for corner cases in
|
|||
:py:mod:`userdbs.tests.test_models`.
|
||||
|
||||
"""
|
||||
from unittest.mock import Mock
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
|
||||
from taskresults.models import TaskResult
|
||||
from userdbs.signals import (
|
||||
handle_dbuser_created,
|
||||
handle_dbuser_deleted,
|
||||
handle_dbuser_password_set,
|
||||
handle_userdb_created,
|
||||
handle_userdb_deleted,
|
||||
)
|
||||
from userdbs.signals import (handle_dbuser_created, handle_dbuser_deleted,
|
||||
handle_dbuser_password_set, handle_userdb_created,
|
||||
handle_userdb_deleted)
|
||||
|
||||
try:
|
||||
from unittest.mock import Mock
|
||||
except ImportError:
|
||||
from mock import Mock
|
||||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
)
|
||||
class TestCaseWithCeleryTasks(TestCase):
|
||||
pass
|
||||
|
||||
|
||||
class TestWithUnknownDBType(TestCaseWithCeleryTasks):
|
||||
|
||||
def test_handle_dbuser_password_set_unknown(self):
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_password_set(Mock(name="sender"), instance, "secret")
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_password_set(Mock(name='sender'), instance, 'secret')
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_dbuser_create_unknown(self):
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_created(Mock(name="sender"), instance, True, password="secret")
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_created(
|
||||
Mock(name='sender'), instance, True, password='secret')
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_dbuser_deleted_unknown(self):
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_deleted(Mock(name="sender"), instance)
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_deleted(Mock(name='sender'), instance)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_userdb_created_unknown(self):
|
||||
instance = Mock(
|
||||
data={
|
||||
"db_name": "test",
|
||||
"db_user": Mock(data={"name": "test", "db_type": -1}),
|
||||
}
|
||||
)
|
||||
handle_userdb_created(Mock(name="sender"), instance, True)
|
||||
'db_name': 'test',
|
||||
'db_user': Mock(data={'name': 'test', 'db_type': -1, })
|
||||
})
|
||||
handle_userdb_created(Mock(name='sender'), instance, True)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_userdb_deleted_unknown(self):
|
||||
instance = Mock(
|
||||
data={
|
||||
"db_name": "test",
|
||||
"db_user": Mock(data={"name": "test", "db_type": -1}),
|
||||
}
|
||||
)
|
||||
handle_userdb_deleted(Mock(name="sender"), instance)
|
||||
'db_name': 'test',
|
||||
'db_user': Mock(data={'name': 'test', 'db_type': -1, })
|
||||
})
|
||||
handle_userdb_deleted(Mock(name='sender'), instance)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
|
|
@ -2,11 +2,16 @@
|
|||
This module provides tests for :py:mod:`userdbs.views`.
|
||||
|
||||
"""
|
||||
from unittest.mock import patch, MagicMock
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
|
||||
try:
|
||||
from unittest.mock import patch, MagicMock
|
||||
except ImportError:
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.urls import reverse
|
||||
|
||||
from hostingpackages.models import (
|
||||
CustomerHostingPackage,
|
||||
|
@ -21,61 +26,58 @@ from userdbs.views import AddUserDatabase, ChangeDatabaseUserPassword
|
|||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_EMAIL = "test@example.org"
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
TEST_EMAIL = 'test@example.org'
|
||||
|
||||
|
||||
class HostingPackageAwareTestMixin(object):
|
||||
|
||||
# noinspection PyMethodMayBeStatic
|
||||
def _setup_hosting_package(self, customer):
|
||||
template = HostingPackageTemplate.objects.create(
|
||||
name="testpackagetemplate", mailboxcount=10, diskspace=1, diskspace_unit=0
|
||||
)
|
||||
name='testpackagetemplate', mailboxcount=10, diskspace=1,
|
||||
diskspace_unit=0)
|
||||
package = CustomerHostingPackage.objects.create_from_template(
|
||||
customer, template, "testpackage"
|
||||
)
|
||||
with patch("hostingpackages.models.settings") as hmsettings:
|
||||
customer, template, 'testpackage')
|
||||
with patch('hostingpackages.models.settings') as hmsettings:
|
||||
hmsettings.OSUSER_DEFAULT_GROUPS = []
|
||||
package.save()
|
||||
return package
|
||||
|
||||
|
||||
class CustomerUserDatabaseOptionAwareTestMixin(object):
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(CustomerUserDatabaseOptionAwareTestMixin, self).__init__(*args, **kwargs)
|
||||
super(CustomerUserDatabaseOptionAwareTestMixin, self).__init__(
|
||||
*args, **kwargs)
|
||||
self._templates = {}
|
||||
|
||||
def _setup_userdatabaseoption(self, number, dbtype):
|
||||
key = "{}_{}".format(dbtype, number)
|
||||
if key not in self._templates:
|
||||
self._templates[key] = UserDatabaseOption.objects.create(
|
||||
number=number, db_type=dbtype
|
||||
)
|
||||
number=number, db_type=dbtype)
|
||||
return self._templates[key]
|
||||
|
||||
def _create_userdatabase_option(self, number=1, dbtype=DB_TYPES.pgsql):
|
||||
# noinspection PyUnresolvedReferences
|
||||
return CustomerUserDatabaseOption.objects.create(
|
||||
template=self._setup_userdatabaseoption(number, dbtype),
|
||||
number=number,
|
||||
db_type=dbtype,
|
||||
hosting_package=self.package,
|
||||
)
|
||||
number=number, db_type=dbtype, hosting_package=self.package)
|
||||
|
||||
|
||||
class AddUserDatabaseTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
|
||||
def _get_url(self):
|
||||
return reverse("add_userdatabase", kwargs={"package": self.package.id})
|
||||
return reverse(
|
||||
'add_userdatabase', kwargs={'package': self.package.id})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
@ -93,29 +95,31 @@ class AddUserDatabaseTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user_nodboption(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 400)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
self._create_userdatabase_option()
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_regular_user_nofree_db(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
UserDatabase.objects.create_userdatabase_with_user(
|
||||
db_option.db_type, self.package.osuser
|
||||
)
|
||||
db_option.db_type, self.package.osuser)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 400)
|
||||
|
@ -124,21 +128,21 @@ class AddUserDatabaseTest(
|
|||
db_option = self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = AddUserDatabase(
|
||||
request=MagicMock(), kwargs={"package": str(self.package.pk)}
|
||||
)
|
||||
request=MagicMock(), kwargs={'package': str(self.package.pk)})
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
self.assertIn("dbtypes", the_kwargs)
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
self.assertIn('dbtypes', the_kwargs)
|
||||
self.assertEqual(
|
||||
the_kwargs["dbtypes"], [(db_option.db_type, DB_TYPES[db_option.db_type])]
|
||||
the_kwargs['dbtypes'],
|
||||
[(db_option.db_type, DB_TYPES[db_option.db_type])],
|
||||
)
|
||||
|
||||
def test_get_template(self):
|
||||
self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, "userdbs/userdatabase_create.html")
|
||||
self.assertTemplateUsed(response, 'userdbs/userdatabase_create.html')
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
|
@ -146,55 +150,48 @@ class AddUserDatabaseTest(
|
|||
response = self.client.post(
|
||||
self._get_url(),
|
||||
data={
|
||||
"db_type": db_option.db_type,
|
||||
"password1": TEST_PASSWORD,
|
||||
"password2": TEST_PASSWORD,
|
||||
},
|
||||
)
|
||||
'db_type': db_option.db_type, 'password1': TEST_PASSWORD,
|
||||
'password2': TEST_PASSWORD})
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(),
|
||||
follow=True,
|
||||
self._get_url(), follow=True,
|
||||
data={
|
||||
"db_type": db_option.db_type,
|
||||
"password1": TEST_PASSWORD,
|
||||
"password2": TEST_PASSWORD,
|
||||
},
|
||||
)
|
||||
db = UserDatabase.objects.filter(db_user__osuser=self.package.osuser).get()
|
||||
messages = list(response.context["messages"])
|
||||
'db_type': db_option.db_type, 'password1': TEST_PASSWORD,
|
||||
'password2': TEST_PASSWORD})
|
||||
db = UserDatabase.objects.filter(
|
||||
db_user__osuser=self.package.osuser).get()
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
str(messages[0]),
|
||||
(
|
||||
"Successfully create new {type} database {dbname} for user " "{dbuser}."
|
||||
).format(type=db.db_user.db_type, dbname=db.db_name, dbuser=db.db_user),
|
||||
)
|
||||
str(messages[0]), (
|
||||
'Successfully create new {type} database {dbname} for user '
|
||||
'{dbuser}.').format(
|
||||
type=db.db_user.db_type, dbname=db.db_name,
|
||||
dbuser=db.db_user))
|
||||
|
||||
|
||||
class ChangeDatabaseUserPasswordTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
template = self._create_userdatabase_option()
|
||||
database = UserDatabase.objects.create_userdatabase_with_user(
|
||||
template.db_type, self.package.osuser
|
||||
)
|
||||
template.db_type, self.package.osuser)
|
||||
self.dbuser = database.db_user
|
||||
|
||||
def _get_url(self, dbuser):
|
||||
return reverse(
|
||||
"change_dbuser_password",
|
||||
kwargs={"package": self.package.id, "slug": dbuser.name},
|
||||
)
|
||||
'change_dbuser_password', kwargs={
|
||||
'package': self.package.id, 'slug': dbuser.name})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
|
@ -206,85 +203,80 @@ class ChangeDatabaseUserPasswordTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertTemplateUsed(response, "userdbs/databaseuser_setpassword.html")
|
||||
self.assertTemplateUsed(
|
||||
response, 'userdbs/databaseuser_setpassword.html')
|
||||
|
||||
def test_get_form_kwargs(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = ChangeDatabaseUserPassword(
|
||||
request=MagicMock(),
|
||||
kwargs={"package": str(self.package.pk), "slug": self.dbuser.name},
|
||||
)
|
||||
view = ChangeDatabaseUserPassword(request=MagicMock(), kwargs={
|
||||
'package': str(self.package.pk), 'slug': self.dbuser.name})
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertIn("dbuser", response.context)
|
||||
self.assertEqual(response.context["dbuser"], self.dbuser)
|
||||
self.assertIn("hostingpackage", response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertIn('dbuser', response.context)
|
||||
self.assertEqual(response.context['dbuser'], self.dbuser)
|
||||
self.assertIn('hostingpackage', response.context)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(self.dbuser),
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
response = self.client.post(self._get_url(self.dbuser), data={
|
||||
'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(self.dbuser),
|
||||
follow=True,
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
messages = list(response.context["messages"])
|
||||
self._get_url(self.dbuser), follow=True, data={
|
||||
'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
str(messages[0]),
|
||||
"Successfully changed password of database user {dbuser}.".format(
|
||||
dbuser=self.dbuser.name
|
||||
),
|
||||
)
|
||||
'Successfully changed password of database user {dbuser}.'.format(
|
||||
dbuser=self.dbuser.name))
|
||||
|
||||
|
||||
class DeleteUserDatabaseTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
template = self._create_userdatabase_option()
|
||||
self.database = UserDatabase.objects.create_userdatabase_with_user(
|
||||
template.db_type, self.package.osuser
|
||||
)
|
||||
template.db_type, self.package.osuser)
|
||||
|
||||
def _get_url(self, userdatabase):
|
||||
return reverse(
|
||||
"delete_userdatabase",
|
||||
kwargs={"package": self.package.id, "slug": userdatabase.db_name},
|
||||
)
|
||||
'delete_userdatabase', kwargs={
|
||||
'package': self.package.id,
|
||||
'slug': userdatabase.db_name})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
|
@ -296,31 +288,34 @@ class DeleteUserDatabaseTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertTemplateUsed(response, "userdbs/userdatabase_confirm_delete.html")
|
||||
self.assertTemplateUsed(
|
||||
response, 'userdbs/userdatabase_confirm_delete.html')
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertIn("database", response.context)
|
||||
self.assertEqual(response.context["database"], self.database)
|
||||
self.assertIn("hostingpackage", response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
self.assertIn('database', response.context)
|
||||
self.assertEqual(response.context['database'], self.database)
|
||||
self.assertIn('hostingpackage', response.context)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
|
@ -330,6 +325,6 @@ class DeleteUserDatabaseTest(
|
|||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(self._get_url(self.database), follow=True)
|
||||
messages = list(response.context["messages"])
|
||||
messages = list(response.context['messages'])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(str(messages[0]), "Database deleted.")
|
||||
|
|
Loading…
Reference in a new issue